Update help file

Update documentation
Update README.md
2025-11-18 06:43:40 -05:00 · 2013-09-17 23:36:58 +09:00 · 2013-09-17 23:32:41 +09:00 · 2013-09-17 15:57:41 +09:00 · 2013-09-17 15:54:33 +09:00 · 2013-09-17 03:12:30 +09:00
13 changed files with 3191 additions and 255 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,5 +1,6 @@
 .gitattributes export-ignore
 .gitignore     export-ignore
 doc/tags       export-ignore
-README.md      export-ignore
+*.md           export-ignore
 zip            export-ignore
+test/*         export-ignore
--- a/EXAMPLES.md
+++ b/EXAMPLES.md
@@ -1,33 +1,50 @@
-vim: set scrolloff=1 buftype=nofile colorcolumn=:
-
 vim-easy-align examples
 =======================

+Open this document in your Vim and try it yourself.
+
+This document assumes that you have defined the following mapping.
+
+```vim
+vnoremap <silent> <Enter> :EasyAlign<cr>
+```
+
 To enable syntax highlighting in the code blocks, define and call the following
 function.

 ```vim
 function! GFM()
-  let syntaxes = {
-  \ 'ruby':   'syntax/ruby.vim',
-  \ 'yaml':   'syntax/yaml.vim',
-  \ 'vim':    'syntax/vim.vim',
-  \ 'c':      'syntax/c.vim'
-  \ }
+  let langs = ['ruby', 'yaml', 'vim', 'c']

-  for [lang, syn] in items(syntaxes)
+  for lang in langs
    unlet b:current_syntax
-    silent! exec printf("syntax include @%s %s", lang, syn)
+    silent! exec printf("syntax include @%s syntax/%s.vim", lang, lang)
    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
 ```

 Alignment around whitespaces
 ----------------------------

+You can align text around whitespaces with `<space>` delimiter key.
+
+Try these commands:
+- `<Enter><space>`
+- `<Enter>2<space>`
+- `<Enter>*<space>`
+- `<Enter>-<space>`
+- `<Enter>-2<space>`
+- `<Enter><Enter><space>`
+- `<Enter><Enter>*<space>`
+- `<Enter><Enter><Enter>*<space>`
+
+### Example
+
 ```

 Paul McCartney 1942
@@ -37,10 +54,20 @@ Pete Best 1941

 ```

-
 Formatting table
 ----------------

+Try these commands:
+- `<Enter>*|`
+- `<Enter>**|`
+- `<Enter><Enter>*|`
+- `<Enter><Enter>**|`
+- `<Enter><Enter><Enter>*|`
+
+### Example
+
+```
+
 | Option| Type | Default | Description |
 |--|--|--|--|
 | threads | Fixnum | 1 | number of threads in the thread pool |
@@ -51,10 +78,24 @@ Formatting table
 |batch_size | Fixnum | nil | number of maximum items to be assigned at once |
 |logger | Logger | nil | logger instance for debug logs |

+```
+

 Alignment around =
 ------------------

+The default rule for delimiter key `=` aligns around a whole family of operators
+containing `=` character.
+
+Try these commands:
+- `<Enter>=`
+- `<Enter>*=`
+- `<Enter>**=`
+- `<Enter><Enter>**=`
+- `<Enter><Enter><Enter>*=`
+
+### Example
+
 ```ruby

 a =
@@ -87,8 +128,10 @@ gg <=> ee
 Formatting YAML (or JSON)
 -------------------------

-```yaml
+Try `<Enter>:` here, to align text around only the first occurrences of colons.
+In this case, you don't want to align around all the colons: `<Enter>*:`.

+```yaml
 mysql:
  # JDBC driver for MySQL database:
  driver: com.mysql.jdbc.Driver
@@ -96,41 +139,258 @@ mysql:
  url: jdbc:mysql://localhost/test
  database: test
  "user:pass":r00t:pa55
-
 ```

-Partial alignment in block-visual mode / Negative field index
-------------------------------------------------------------
+Formatting multi-line method chaining
+-------------------------------------
+
+Try `<Enter>.` or `<Enter>*.` on the following lines.

 ```ruby
+my_object
+      .method1().chain()
+    .second_method().call()
+      .third().call()
+     .method_4().execute()
+```

+Notice that the indentation is adjusted to match the shortest one among those of
+the lines starting with the delimiter.
+
+```ruby
+my_object
+    .method1()      .chain()
+    .second_method().call()
+    .third()        .call()
+    .method_4()     .execute()
+```
+
+
+Using blockwise-visual mode or negative field index
+---------------------------------------------------
+
+You can try either:
+- select text around `=>` in blockwise-visual mode (`CTRL-V`) and `<Enter>=`
+- or `<Enter>-=`
+
+```ruby
 options = { :caching => nil,
            :versions => 3,
            "cache=blocks" => false }.merge(options)
-
 ```

 Commas
 ------

-```
+There is also a predefined rule for commas, try `<Enter>*,` on the following
+lines.

+```
 aaa,   bb,c
 d,eeeeeee
 fffff, gggggggggg,
 h, ,           ii
 j,,k
-
 ```

-Ignoring delimiters in comments and strings
-------------------------------------------
+Ignoring delimiters in comments or strings
+------------------------------------------
+
+Delimiters highlighted as comments or strings are ignored by default, try
+`<Enter>*=` on the following lines.

 ```c
+
 /* a */ b = c
 aa >= bb
 // aaa = bbb = cccc
 /* aaaa = */ bbbb   === cccc   " = dddd = " = eeee
 aaaaa /* bbbbb */      == ccccc /* != eeeee = */ === fffff
+
+```
+
+This only works when syntax highlighting is enabled.
+
+Aligning in-line comments
+-------------------------
+
+```ruby
+apple = 1 # comment not aligned
+banana = 'Gros Michel' # comment 2
+```
+
+So, how do we align the trailing comments in the above lines?
+Simply try `<Enter>-<space>`. The spaces in the comments are ignored, so the
+trailing comment in each line is considered to be a single chunk.
+
+But that doesn't work in the following case.
+
+```ruby
+apple = 1 # comment not aligned
+apricot = 'DAD' + 'F#AD'
+banana = 'Gros Michel' # comment 2
+```
+
+That is because the second line doesn't have trailing comment, and
+the last (`-`) space for that line is the one just before `'F#AD'`.
+
+So, let's define a custom mapping for `#`.
+
+```vim
+if !exists('g:easy_align_delimiters')
+  let g:easy_align_delimiters = {}
+endif
+let g:easy_align_delimiters['#'] = { 'pattern': '#', 'ignore_groups': ['String'] }
+```
+
+Notice that the rule overrides `ignore_groups` attribute in order *not to ignore*
+delimiters highlighted as comments.
+
+Then on `<Enter>#`, we get
+
+```ruby
+apple = 1         # comment not aligned
+apricot = 'DAD' + 'F#AD'
+banana = 'string' # comment 2
+```
+
+If you don't want to define the rule, you can do the same with the following
+command:
+
+```vim
+" Using regular expression /#/
+" - "is" is fuzzy-matched to "*i*gnore*s*"
+:EasyAlign/#/{'is':['String']}
+```
+
+In this case, the second line is ignored as it doesn't contain a `#`. (The one
+highlighted as String is ignored.) If you don't want the second line to be
+ignored, there are three options:
+
+1. Set global `g:easy_align_ignore_unmatched` flag to 0
+2. Use `:EasyAlign` command with `ignore_unmatched` option
+3. Update the alignment rule with `ignore_unmatched` option
+
+```vim
+" 1. Set global g:easy_align_ignore_unmatched to zero
+let g:easy_align_ignore_unmatched = 0
+
+" 2. Using :EasyAlign command with ignore_unmatched option
+" 2-1. Using predefined rule with delimiter key #
+"      - "iu" is fuzzy-matched to "*i*gnore_*u*nmatched"
+:EasyAlign#{'iu':0}
+
+" 2-2. Using regular expression /#/
+:EasyAlign/#/{'is':['String'],'iu':0}
+
+" 3. Update the alignment rule with ignore_unmatched option
+let g:easy_align_delimiters['#'] = {
+  \ 'pattern': '#', 'ignore_groups': ['String'], 'ignore_unmatched': 0 }
+```
+
+Then we get,
+
+```ruby
+apple = 1                # comment not aligned
+apricot = 'DAD' + 'F#AD'
+banana = 'string'        # comment 2
+```
+
+Aligning C-style variable definition
+------------------------------------
+
+Take the following example:
+
+```c
+const char* str = "Hello";
+int64_t count = 1 + 2;
+static double pi = 3.14;
+```
+
+We can align these lines with the predefined `=` rule. Select the lines and
+press `<Enter>=`
+
+```c
+const char* str  = "Hello";
+int64_t count    = 1 + 2;
+static double pi = 3.14;
+```
+
+Not bad. However, the names of the variables, `str`, `count`, and `pi` are not
+aligned with each other. Can we do better? We can clearly see that simple
+`<Enter><space>` won't properly align those names.
+So let's define an alignment rule than can handle this case.
+
+```vim
+let g:easy_align_delimiters['d'] = {
+\ 'pattern': '\(const\|static\)\@<! ',
+\ 'left_margin': 0, 'right_margin': 0
+\ }
+```
+
+This new rule aligns text around spaces that are *not* preceded by
+`const` or `static`. Let's try it with `<Enter>d`.
+
+```c
+const char*   str = "Hello";
+int64_t       count = 1 + 2;
+static double pi = 3.14;
+```
+
+Okay, the names are now aligned. We select the lines again with `gv`, and then
+press `<Enter>=` to finish our alignment.
+
+```c
+const char*   str   = "Hello";
+int64_t       count = 1 + 2;
+static double pi    = 3.14;
+```
+
+So far, so good. However, this rule is not sufficient to handle more complex
+cases involving C++ templates or Java generics. Take the following example:
+
+```c
+const char* str = "Hello";
+int64_t count = 1 + 2;
+static double pi = 3.14;
+static std::map<std::string, float>*    scores = pointer;
+```
+
+We see that our rule above doesn't work anymore.
+
+```c
+const char*                  str = "Hello";
+int64_t                      count = 1 + 2;
+static double                pi = 3.14;
+static std::map<std::string, float>*    scores = pointer;
+```
+
+So what do we do? Let's try to improve our alignment rule.
+
+```vim
+let g:easy_align_delimiters['d'] = {
+\ 'pattern': ' \(\S\+\s*[;=]\)\@=',
+\ 'left_margin': 0, 'right_margin': 0
+\ }
+```
+
+Now the new rule has changed to align text around spaces that are followed
+by some non-whitespace characters and then an equals sign or a semi-colon.
+Try `<Enter>d`
+
+```c
+const char*                          str = "Hello";
+int64_t                              count = 1 + 2;
+static double                        pi = 3.14;
+static std::map<std::string, float>* scores = pointer;
+```
+
+We're right on track, now press `gv<Enter>=` and voila!
+
+```c
+const char*                          str    = "Hello";
+int64_t                              count  = 1 + 2;
+static double                        pi     = 3.14;
+static std::map<std::string, float>* scores = pointer;
 ```

--- a/README.md
+++ b/README.md
@@ -1,40 +1,76 @@
 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)

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

+- Easy to use
+  - Comes with a predefined set of alignment rules
+  - Provides a fast and intuitive interface
+- Extensible
+  - You can define your own rules
+  - Supports arbitrary regular expressions
 - Optimized for code editing
- Designed to require minimal keystrokes
- Extensible alignment rules
- Aligns text around either _all or n-th_ occurrence(s) of the delimiter
- Ignores delimiters in certain syntax highlight groups (e.g. comments, strings)
- Ignores lines without a matching delimiter
+  - 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.
+
 Usage
 -----

-_vim-easy-align_ defines interactive `:EasyAlign` command in the visual mode.
+_vim-easy-align_ defines `:EasyAlign` command (and the right-align
+variant `:EasyAlign!`) for visual mode.
+
+| Mode                      | Command                                          |
+| ------------------------- | ------------------------------------------------ |
+| Interactive mode          | `:EasyAlign[!] [OPTIONS]`                        |
+| Using predefined rules    | `:EasyAlign[!] [FIELD#] DELIMITER_KEY [OPTIONS]` |
+| Using regular expressions | `:EasyAlign[!] [FIELD#] /REGEXP/ [OPTIONS]`      |
+
+### 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
+
+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`.

@@ -42,10 +78,12 @@ your `.vimrc`.
 vnoremap <silent> <Enter> :EasyAlign<cr>
 ```

-With the mapping, you can align selected lines with a few keystrokes.
+(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 Enter keys to select alignment mode (left, right, or center)
 1. Optional field number (default: 1)
    - `1`         Around the 1st occurrences of delimiters
    - `2`         Around the 2nd occurrences of delimiters
@@ -59,31 +97,129 @@ With the mapping, you can align selected lines with a few keystrokes.

 Alignment rules for the following delimiters have been defined to meet the most needs.

-| Delimiter key | Description/Use cases                                      |
-| ------------- | ---------------------------------------------------------- |
-| `<space>`     | General alignment around spaces                            |
-| `=`           | Operators containing equals sign (=, ==, !=, +=, &&=, ...) |
-| `:`           | Suitable for formatting JSON or YAML                       |
-| `.`           | Multi-line method chaining                                 |
-| `,`           | Multi-line method arguments                                |
-| &#124;        | Table markdown                                             |
+| Delimiter key | Description/Use cases                                                |
+| ------------- | -------------------------------------------------------------------- |
+| `<space>`     | General alignment around whitespaces                                 |
+| `=`           | Operators containing equals sign (`=`, `==,` `!=`, `+=`, `&&=`, ...) |
+| `:`           | Suitable for formatting JSON or YAML                                 |
+| `.`           | Multi-line method chaining                                           |
+| `,`           | Multi-line method arguments                                          |
+| &#124;        | Table markdown                                                       |

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

-| 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        | `:'<,'>EasyAlignRight=`   |
-| `<Enter><Enter>**=` | Right-left alternating alignment around all equals signs | `:'<,'>EasyAlignRight**=` |
-| ...                 | ...                                                      |                           |
+#### 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 alignment around 1st equals signs                  | `:'<,'>EasyAlign!=`   |
+| `<Enter><Enter>**=` | Right-left alternating alignment around all equals signs | `:'<,'>EasyAlign!**=` |
+| ...                 | ...                                                      |                       |
+
+#### Using 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-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 }`         |
+
+---
+
+### *Intermission*
+
+You can stop reading here. Trust me. All the fancy features described in the
+following sections are really powerful but you won't be needing them in most
+of the cases.
+
+Go try out vim-easy-align right now, and come back later when you feel like it.
+
+---
+
+### Non-interactive mode
+
+Instead of going into the interactive mode, you can type in arguments to
+`:EasyAlign` command.
+
+```vim
+" Using predefined alignment rules
+:EasyAlign[!] [FIELD#] DELIMITER_KEY [OPTIONS]
+
+" Using arbitrary regular expressions
+:EasyAlign[!] [FIELD#] /REGEXP/ [OPTIONS]
+```
+
+For example, when aligning the following lines around colons and semi-colons,
+
+    apple;:banana::cake
+    data;;exchange:;format
+
+try these commands:
+
+- `:EasyAlign /[:;]\+/`
+- `:EasyAlign 2/[:;]\+/`
+- `:EasyAlign */[:;]\+/`
+- `:EasyAlign **/[:;]\+/`
+
+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.
+
+- `:EasyAlign * /[:;]\+/ { 'stick_to_left': 1, 'left_margin': 0 }`
+
+Then we get:
+
+    apple;: banana::   cake
+    data;;  exchange:; format
+
+Option names are fuzzy-matched, so you can write as follows:
+
+- `:EasyAlign * /[:;]\+/ { 'stl': 1, 'l': 0 }`
+
+You can even omit spaces between the arguments, so concisely (or cryptically):
+
+- `:EasyAlign*/[:;]\+/{'s':1,'l':0}`
+
+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

@@ -112,14 +248,41 @@ 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>-=`

-Options
-------
+Alignment options
+-----------------

-| Option                        | Type       | Default               | Description                                        |
-| ----------------------------- | ---------- | --------------------- | -------------------------------------------------- |
-| g:easy_align_ignores          | list       | ['String', 'Comment'] | Ignore delimiters in these syntax highlight groups |
-| g:easy_align_ignore_unmatched | boolean    | `1`                   | Ignore lines without matching delimiter            |
-| g:easy_align_delimiters       | dictionary | `{}`                  | Extend or override alignment rules                 |
+### List of options
+
+| Option             | Type    | Default               | Description                                             |
+| ------------------ | ------- | --------------------- | ------------------------------------------------------- |
+| `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  |
+
+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 a dictionary argument to `:EasyAlign` command
+4. Option values can be set in interactive mode using special shortcut keys
+
+| Option             | Shortcut key        | Global variable                 |
+| ------------------ | ------------------- | ------------------------------- |
+| `left_margin`      | `CTRL-L`            |                                 |
+| `right_margin`     | `CTRL-R`            |                                 |
+| `stick_to_left`    | `<Left>`, `<Right>` |                                 |
+| `ignore_groups`    | `CTRL-G`            | `g:easy_align_ignore_groups`    |
+| `ignore_unmatched` | `CTRL-U`            | `g:easy_align_ignore_unmatched` |
+| `indentation`      | `CTRL-I`            | `g:easy_align_indentation`      |
+| `delimiter_align`  | `CTRL-D`            | `g:easy_align_delimiter_align`  |
+| `mode_sequence`    | `CTRL-O`            |                                 |

 ### Ignoring delimiters in comments or strings

@@ -131,7 +294,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
@@ -147,7 +310,7 @@ For example, the following paragraph
 }
 ```

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

 ```ruby
 {
@@ -162,14 +325,15 @@ becomes as follows on `<Enter>:`

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

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

-```vim
-" 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':[]}`

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

 ```ruby
 {
@@ -187,7 +351,7 @@ Satisfied? :satisfied:
 ### Ignoring unmatched lines

 Lines without any matching delimiter are ignored as well (except in
-right-justification mode).
+right-align mode).

 For example, when aligning the following code block around the colons,

@@ -213,11 +377,13 @@ this is usually what we want.
 }
 ```

-However, this default behavior is also configurable.
+However, this default behavior is also configurable by using one of these 4
+methods.

-```vim
-let g:easy_align_ignore_unmatched = 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:{'iu':0}`

 Then we get,

@@ -231,29 +397,285 @@ Then we get,
 }
 ```

-### Extending alignment rules
+### Aligning delimiters of different lengths
+
+Global `g:easy_align_delimiter_align` option and rule-wise/command-wise
+`delimiter_align` option determines how matched delimiters of different lengths
+are aligned.
+
+```ruby
+apple = 1
+banana += apple
+cake ||= banana
+```
+
+By default, delimiters are right-aligned as follows.
+
+```ruby
+apple    = 1
+banana  += apple
+cake   ||= banana
+```
+
+However, with `:EasyAlign={'da':l}`, delimiters are left-aligned.
+
+```ruby
+apple  =   1
+banana +=  apple
+cake   ||= banana
+```
+
+And on `:EasyAlign={'da':c}`, center-aligned.
+
+```ruby
+apple   =  1
+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={'idt':s}
+  apple    = 1
+  banana   = 2
+  cake     = 3
+  daisy    = 4
+  eggplant = 5
+
+# Use the _d_eepest indentation among the lines
+#   :EasyAlign={'idt':d}
+        apple    = 1
+        banana   = 2
+        cake     = 3
+        daisy    = 4
+        eggplant = 5
+
+# Indentation: _n_one
+#   :EasyAlign={'idt':n}
+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.
+
+### 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']
+```
+
+### Alignments over multiple occurrences of delimiters
+
+As stated above, "field number" 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' }
+
+" Right, left, center alignment over the 2nd to 4th occurrences of delimiters
+:EasyAlign 2={ 'm': 'rlc' }
+
+" (*) Repeating alignments (default: l, r, or c)
+"   Right, left, center, center, center, center, ...
+:EasyAlign *={ 'm': 'rlc' }
+
+" (**) Alternating alignments (default: lr or rl)
+"   Right, left, center, right, left, center, ...
+:EasyAlign **={ 'm': 'rlc' }
+
+" Right, left, center, center, center, ... repeating alignment
+" over the 3rd to the last occurrences of delimiters
+:EasyAlign 3={ 'm': 'rlc*' }
+
+" Right, left, center, right, left, center, ... alternating alignment
+" over the 3rd to the last occurrences of delimiters
+:EasyAlign 3={ 'm': 'rlc**' }
+```
+
+### 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`.
+
+#### Example

 ```vim
-" Examples
 let g:easy_align_delimiters = {
 \ '>': { 'pattern': '>>\|=>\|>' },
-\ '/': { 'pattern': '//\+\|/\*\|\*/' },
-\ '#': { 'pattern': '#\+' },
+\ '/': { 'pattern': '//\+\|/\*\|\*/', 'ignore_groups': ['String'] },
+\ '#': { 'pattern': '#\+', 'ignore_groups': ['String'], 'delimiter_align': 'l' },
 \ ']': {
-\     'pattern':       '[\[\]]',
-\     'margin_left':   '',
-\     'margin_right':  '',
+\     'pattern':       '[[\]]',
+\     'left_margin':   0,
+\     'right_margin':  0,
 \     'stick_to_left': 0
 \   },
 \ ')': {
 \     'pattern':       '[()]',
-\     'margin_left':   '',
-\     'margin_right':  '',
+\     'left_margin':   0,
+\     'right_margin':  0,
 \     'stick_to_left': 0
+\   },
+\ 'd': {
+\     'pattern': ' \(\S\+\s*[;=]\)\@=',
+\     'left_margin': 0,
+\     'right_margin': 0
 \   }
 \ }
 ```

+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)
+
+### "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
@@ -27,19 +27,33 @@ endif
 let g:loaded_easy_align = 1

 let s:easy_align_delimiters_default = {
-\  ' ': { 'pattern': ' ',  'margin_left': '',  'margin_right': '',  'stick_to_left': 0 },
-\  '=': { 'pattern': '===\|<=>\|\(&&\|||\|<<\|>>\)=\|=\~\|=>\|[:+/*!%^=><&|-]\?=[#?]\?',
-\                          'margin_left': ' ', 'margin_right': ' ', 'stick_to_left': 0 },
-\  ':': { 'pattern': ':',  'margin_left': '',  'margin_right': ' ', 'stick_to_left': 1 },
-\  ',': { 'pattern': ',',  'margin_left': '',  'margin_right': ' ', 'stick_to_left': 1 },
-\  '|': { 'pattern': '|',  'margin_left': ' ', 'margin_right': ' ', 'stick_to_left': 0 },
-\  '.': { 'pattern': '\.', 'margin_left': '',  'margin_right': '',  'stick_to_left': 0 },
+\  ' ': { 'pattern': ' ',  'left_margin': 0, 'right_margin': 0, 'stick_to_left': 0 },
+\  '=': { 'pattern': '===\|<=>\|\(&&\|||\|<<\|>>\)=\|=\~[#?]\?\|=>\|[:+/*!%^=><&|.-]\?=[#?]\?',
+\                          'left_margin': 1, 'right_margin': 1, 'stick_to_left': 0 },
+\  ':': { 'pattern': ':',  'left_margin': 0, 'right_margin': 1, 'stick_to_left': 1 },
+\  ',': { 'pattern': ',',  'left_margin': 0, 'right_margin': 1, 'stick_to_left': 1 },
+\  '|': { 'pattern': '|',  'left_margin': 1, 'right_margin': 1, 'stick_to_left': 0 },
+\  '.': { 'pattern': '\.', 'left_margin': 0, 'right_margin': 0, 'stick_to_left': 0 },
 \  '{': { 'pattern': '(\@<!{',
-\                          'margin_left': ' ', 'margin_right': ' ', 'stick_to_left': 0 },
-\  '}': { 'pattern': '}',  'margin_left': ' ', 'margin_right': '',  'stick_to_left': 0 }
+\                          'left_margin': 1, 'right_margin': 1, 'stick_to_left': 0 },
+\  '}': { 'pattern': '}',  'left_margin': 1, 'right_margin': 0, 'stick_to_left': 0 }
 \ }

-let s:just = ['', '[R]']
+let s:mode_labels = { 'l': '', 'r': '[R]', 'c': '[C]' }
+
+let s:known_options = {
+\ 'margin_left':   [0, 1], 'margin_right':     [0, 1], 'stick_to_left':   [0],
+\ 'left_margin':   [0, 1], 'right_margin':     [0, 1], 'indentation':     [1],
+\ 'ignore_groups': [3   ], 'ignore_unmatched': [0   ], 'delimiter_align': [1],
+\ 'mode_sequence': [1   ], 'ignores': [3]
+\ }
+
+let s:option_values = {
+\ 'indentation':      ['shallow', 'deep', 'none', 'keep'],
+\ 'delimiter_align':  ['left', 'center', 'right'],
+\ 'ignore_unmatched': [0, 1],
+\ 'ignore_groups':    [[], ['String'], ['Comment'], ['String', 'Comment']]
+\ }

 if exists("*strwidth")
  function! s:strwidth(str)
@@ -65,62 +79,219 @@ endfunction
 function! s:ignored_syntax()
  if has('syntax') && exists('g:syntax_on')
    " Backward-compatibility
-    return get(g:, 'easy_align_ignores',
-          \ (get(g:, 'easy_align_ignore_comment', 1) == 0) ?
-            \ ['String'] : ['String', 'Comment'])
+    return get(g:, 'easy_align_ignore_groups',
+          \ get(g:, 'easy_align_ignores',
+            \ (get(g:, 'easy_align_ignore_comment', 1) == 0) ?
+              \ ['String'] : ['String', 'Comment']))
  else
    return []
  endif
 endfunction

-function! s:do_align(just, all_tokens, fl, ll, fc, lc, pattern, nth, ml, mr, stick_to_left, recursive)
-  let lines          = {}
-  let max_just_len   = 0
-  let max_delim_len  = 0
-  let max_tokens     = 0
-  let pattern        = '\s*\(' .a:pattern. '\)\s' . (a:stick_to_left ? '*' : '\{-}')
-  let ignored_syntax = s:ignored_syntax()
+function! s:echon(l, n, d, o)
+  echon "\r"
+  echon "\rEasyAlign". s:mode_labels[a:l] ." (" .a:n.a:d. ")"
+        \ . (empty(a:o) ? '' : ' '.string(a:o))
+endfunction
+
+function! s:exit(msg)
+  echon "\r". a:msg
+  throw 'exit'
+endfunction
+
+function! s:ltrim(str)
+  return substitute(a:str, '^\s*', '', '')
+endfunction
+
+function! s:rtrim(str)
+  return substitute(a:str, '\s*$', '', '')
+endfunction
+
+function! s:trim(str)
+  return substitute(a:str, '^\s*\(\S*\)\s*$', '\1', '')
+endfunction
+
+function! s:fuzzy_lu(key)
+  if has_key(s:known_options, a:key)
+    return a:key
+  endif
+  let key = tolower(a:key)
+
+  " stl -> ^s.*_t.*_l.*
+  let regexp1 = '^' .key[0]. '.*' .substitute(key[1 : -1], '\(.\)', '_\1.*', 'g')
+  let matches = filter(keys(s:known_options), 'v:val =~ regexp1')
+  if len(matches) == 1
+    return matches[0]
+  endif
+
+  " stl -> ^s.*t.*l.*
+  let regexp2 = '^' . substitute(substitute(key, '-', '_', 'g'), '\(.\)', '\1.*', 'g')
+  let matches = filter(keys(s:known_options), 'v:val =~ regexp2')
+
+  if empty(matches)
+    call s:exit("Unknown option key: ". a:key)
+  elseif len(matches) == 1
+    return matches[0]
+  else
+    " Avoid ambiguity introduced by deprecated margin_left and margin_right
+    if sort(matches) == ['margin_left', 'margin_right', 'mode_sequence']
+      return 'mode_sequence'
+    endif
+    if sort(matches) == ['ignore_groups', 'ignores']
+      return 'ignore_groups'
+    endif
+    call s:exit("Ambiguous option key: ". a:key ." (" .join(matches, ', '). ")")
+  endif
+endfunction
+
+function! s:shift(modes, cycle)
+  let item = remove(a:modes, 0)
+  if a:cycle || empty(a:modes)
+    call add(a:modes, item)
+  endif
+  return item
+endfunction
+
+function! s:normalize_options(opts)
+  let ret = {}
+  for k in keys(a:opts)
+    let v = a:opts[k]
+    let k = s:fuzzy_lu(k)
+    " Backward-compatibility
+    if k == 'margin_left'  | let k = 'left_margin'  | endif
+    if k == 'margin_right' | let k = 'right_margin' | endif
+    let ret[k] = v
+    unlet v
+  endfor
+  return s:validate_options(ret)
+endfunction
+
+function! s:validate_options(opts)
+  for k in keys(a:opts)
+    let v = a:opts[k]
+    if index(s:known_options[k], type(v)) == -1
+      call s:exit("Invalid type for option: ". k)
+    endif
+    unlet v
+  endfor
+  return a:opts
+endfunction
+
+function! s:split_line(line, nth, modes, cycle, fc, lc, pattern, stick_to_left, ignore_unmatched, ignore_groups)
+  let mode = ''
+
+  let string = a:lc ?
+    \ strpart(getline(a:line), a:fc - 1, a:lc - a:fc + 1) :
+    \ strpart(getline(a:line), a:fc - 1)
+  let idx     = 0
+  " Do not allow \zs
+  " 1: whole match
+  " 2: token
+  " 3: delimiter
+  let pattern = '^\(\(.\{-}\s*\)\(' .a:pattern. '\)\s' . (a:stick_to_left ? '*' : '\{-}') . '\)'
+  let tokens  = []
+  let delims  = []
+
+  " Phase 1: split
+  let ignorable = 0
+  let token = ''
+  while 1
+    let matches = matchlist(string, pattern, idx)
+    " No match
+    if empty(matches) | break | endif
+
+    " Match, but empty delimiter
+    if empty(matches[1])
+      let char = strpart(string, idx, 1)
+      if empty(char) | break | endif
+      let [match, part, delim] = [char, char, '']
+    " Match
+    else
+      let [match, part, delim] = matches[1 : 3]
+    endif
+
+    let ignorable = s:highlighted_as(a:line, idx + len(part) + a:fc, a:ignore_groups)
+    if ignorable
+      let token .= match
+    else
+      let [pmode, mode] = [mode, s:shift(a:modes, a:cycle)]
+      call add(tokens, token . match)
+      call add(delims, delim)
+      let token = ''
+    endif
+
+    let idx += len(match)
+
+    " If the string is non-empty and ends with the delimiter,
+    " append an empty token to the list
+    if idx == len(string)
+      call add(tokens, '')
+      call add(delims, '')
+      break
+    endif
+  endwhile
+
+  let leftover = token . strpart(string, idx)
+  if !empty(leftover)
+    let ignorable = s:highlighted_as(a:line, len(string) + a:fc - 1, a:ignore_groups)
+    call add(tokens, leftover)
+    call add(delims, '')
+  endif
+  let [pmode, mode] = [mode, s:shift(a:modes, a:cycle)]
+
+  " Preserve indentation - merge first two tokens
+  if len(tokens) > 1 && empty(s:rtrim(tokens[0]))
+    let tokens[1] = tokens[0] . tokens[1]
+    call remove(tokens, 0)
+    call remove(delims, 0)
+    let mode = pmode
+  endif
+
+  " Skip comment line
+  if ignorable && len(tokens) == 1 && a:ignore_unmatched
+    let tokens = []
+    let delims = []
+  " Append an empty item to enable right/center alignment of the last token
+  " - if the last token is not ignorable or ignorable but not the only token
+  elseif (mode ==? 'r' || mode ==? 'c') && (!ignorable || len(tokens) > 1) && a:nth >= 0 " includes -0
+    call add(tokens, '')
+    call add(delims, '')
+  endif
+
+  return [tokens, delims]
+endfunction
+
+function! s:max(old, new)
+  for k in keys(a:new)
+    if a:new[k] > a:old[k]
+      let a:old[k] = a:new[k] " max() doesn't work with Floats
+    endif
+  endfor
+endfunction
+
+function! s:do_align(modes, all_tokens, all_delims, fl, ll, fc, lc, pattern, nth,
+      \ ml, mr, da, indentation, stick_to_left, ignore_unmatched, ignore_groups, recur)
+  let mode       = a:modes[0]
+  let lines      = {}
+  let min_indent = -1
+  let max = { 'pivot_len': 0.0, 'token_len': 0, 'just_len': 0, 'delim_len': 0,
+        \ 'indent': 0, 'tokens': 0, 'strip_len': 0 }

  " Phase 1
  for line in range(a:fl, a:ll)
    if !has_key(a:all_tokens, line)
      " Split line into the tokens by the delimiters
-      let raw_tokens = split(a:lc ?
-                        \ strpart(getline(line), a:fc - 1, a:lc - a:fc + 1) :
-                        \ strpart(getline(line), a:fc - 1),
-                        \ pattern.'\zs')
-      let concat = 0
-      if empty(ignored_syntax)
-        let tokens = raw_tokens
-      else
-        " Concat adjacent tokens that are split by ignorable delimiters
-        let tokens = []
-        let idx    = 0
-        for token in raw_tokens
-          let idx += len(token)
-          if concat
-            let tokens[len(tokens) - 1] .= token
-          else
-            call add(tokens, token)
-          endif
-          let concat = s:highlighted_as(line, idx + a:fc - 1, ignored_syntax)
-        endfor
-      endif
-
-      " Preserve indentation - merge first two tokens
-      if !empty(tokens) && match(tokens[0], '^\s*$') != -1
-        let tokens = extend([join(tokens[0:1], '')], tokens[2:-1])
-      endif
-
-      " Skip comment line
-      if concat && len(tokens) == 1
-        let tokens = []
-      endif
+      let [tokens, delims] = s:split_line(
+            \ line, a:nth, copy(a:modes), a:recur == 2,
+            \ a:fc, a:lc, a:pattern,
+            \ a:stick_to_left, a:ignore_unmatched, a:ignore_groups)

      " Remember tokens for subsequent recursive calls
      let a:all_tokens[line] = tokens
+      let a:all_delims[line] = delims
    else
      let tokens = a:all_tokens[line]
+      let delims = a:all_delims[line]
    endif

    " Skip empty lines
@@ -129,16 +300,20 @@ function! s:do_align(just, all_tokens, fl, ll, fc, lc, pattern, nth, ml, mr, sti
    endif

    " Calculate the maximum number of tokens for a line within the range
-    let max_tokens = max([len(tokens), max_tokens])
+    call s:max(max, { 'tokens': len(tokens) })

    if a:nth > 0 " Positive field number
      if len(tokens) < a:nth
        continue
      endif
      let nth = a:nth - 1 " make it 0-based
-    else " Negative field number
-      let nth = len(tokens) + a:nth
-      if match(tokens[len(tokens) - 1], pattern.'$') == -1
+    else " -0 or Negative field number
+      if a:nth == 0 && mode !=? 'l'
+        let nth = len(tokens) - 1
+      else
+        let nth = len(tokens) + a:nth
+      endif
+      if empty(delims[len(delims) - 1])
        let nth -= 1
      endif

@@ -147,46 +322,122 @@ function! s:do_align(just, all_tokens, fl, ll, fc, lc, pattern, nth, ml, mr, sti
      endif
    endif

-    let last   = tokens[nth]
-    let prefix = (nth > 0 ? join(tokens[0 : nth - 1], '') : '')
-    let token  = substitute(last, pattern.'$', '', '')
-
-    let delim = get(matchlist(last, pattern.'$'), 1, '')
-    if empty(delim) && a:just == 0 && get(g:, 'easy_align_ignore_unmatched', 1)
+    let prefix = nth > 0 ? join(tokens[0 : nth - 1], '') : ''
+    let delim  = delims[nth]
+    let token  = s:rtrim( tokens[nth] )
+    let token  = s:rtrim( strpart(token, 0, len(token) - len(s:rtrim(delim))) )
+    if empty(delim) && !exists('tokens[nth + 1]') && a:ignore_unmatched
      continue
    endif

-    let max_just_len  = max([s:strwidth(prefix.token), max_just_len])
-    let max_delim_len = max([s:strwidth(delim), max_delim_len])
+    let indent        = len(matchstr(tokens[0], '^\s\+'))
+    if min_indent < 0 || indent < min_indent
+      let min_indent  = indent
+    endif
+    if mode ==? 'c' | let token .= matchstr(token, '^\s*') | endif
+    let [pw, tw] = [s:strwidth(prefix), s:strwidth(token)]
+    call s:max(max, { 'indent': indent, 'token_len': tw, 'just_len': pw + tw,
+                     \ 'delim_len': s:strwidth(delim) })
+    if mode ==? 'c'
+      call s:max(max, { 'pivot_len': pw + tw / 2.0,
+                       \ 'strip_len': s:strwidth(s:trim(token)) })
+    endif
    let lines[line]   = [nth, prefix, token, delim]
  endfor

+  " Phase 1-5: indentation handling (only on a:nth == 1)
+  if a:nth == 1
+    if a:indentation ==? 'd'
+      let indent = repeat(' ', max.indent)
+    elseif a:indentation ==? 's'
+      let indent = repeat(' ', min_indent)
+    elseif a:indentation ==? 'n'
+      let indent = ''
+    elseif a:indentation !=? 'k'
+      call s:exit('Invalid indentation: ' . a:indentation)
+    end
+
+    if a:indentation !=? 'k'
+      let max.just_len  = 0
+      let max.token_len = 0
+      let max.pivot_len = 0
+
+      for [line, elems] in items(lines)
+        let [nth, prefix, token, delim] = elems
+
+        let token = substitute(token, '^\s*', indent, '')
+        if mode ==? 'c'
+          let token = substitute(token, '\s*$', indent, '')
+        endif
+        let [pw, tw] = [s:strwidth(prefix), s:strwidth(token)]
+        call s:max(max, { 'token_len': tw, 'just_len': pw + tw })
+        if mode ==? 'c'
+          call s:max(max, { 'pivot_len': pw + tw / 2.0 })
+        endif
+
+        let lines[line][2] = token
+      endfor
+    endif
+  endif
+
  " Phase 2
  for [line, elems] in items(lines)
    let tokens = a:all_tokens[line]
+    let delims = a:all_delims[line]
    let [nth, prefix, token, delim] = elems

    " Remove the leading whitespaces of the next token
    if len(tokens) > nth + 1
-      let tokens[nth + 1] = substitute(tokens[nth + 1], '^\s*', '', '')
+      let tokens[nth + 1] = s:ltrim(tokens[nth + 1])
    endif

    " Pad the token with spaces
-    let pad = repeat(' ', max_just_len - s:strwidth(prefix) - s:strwidth(token))
+    let [pw, tw] = [s:strwidth(prefix), s:strwidth(token)]
    let rpad = ''
-    if a:just == 0
+    if mode ==? 'l'
+      let pad = repeat(' ', max.just_len - pw - tw)
      if a:stick_to_left
        let rpad = pad
      else
        let token = token . pad
      endif
-    elseif a:just == 1
+    elseif mode ==? 'r'
+      let pad = repeat(' ', max.just_len - pw - tw)
      let token = pad . token
+    elseif mode ==? 'c'
+      let p1  = max.pivot_len - (pw + tw / 2.0)
+      let p2  = (max.token_len - tw) / 2.0
+      let pf1 = floor(p1)
+      if pf1 < p1 | let p2 = ceil(p2)
+      else        | let p2 = floor(p2)
+      endif
+      let strip = float2nr(ceil((max.token_len - max.strip_len) / 2.0))
+      let token = repeat(' ', float2nr(pf1)) .token. repeat(' ', float2nr(p2))
+      let token = substitute(token, repeat(' ', strip) . '$', '', '')
+
+      if a:stick_to_left
+        if empty(s:rtrim(token))
+          let center = len(token) / 2
+          let [token, rpad] = [strpart(token, 0, center), strpart(token, center)]
+        else
+          let [token, rpad] = [s:rtrim(token), matchstr(token, '\s*$')]
+        endif
+      endif
    endif
    let tokens[nth] = token

    " Pad the delimiter
-    let delim   = repeat(' ', max_delim_len - s:strwidth(delim)). delim
+    let dpadl = max.delim_len - s:strwidth(delim)
+    if a:da ==? 'l'
+      let [dl, dr] = ['', repeat(' ', dpadl)]
+    elseif a:da ==? 'c'
+      let dl = repeat(' ', dpadl / 2)
+      let dr = repeat(' ', dpadl - dpadl / 2)
+    elseif a:da ==? 'r'
+      let [dl, dr] = [repeat(' ', dpadl), '']
+    else
+      call s:exit('Invalid delimiter_align: ' . a:da)
+    endif

    " Before and after the range (for blockwise visual mode)
    let cline   = getline(line)
@@ -199,82 +450,227 @@ function! s:do_align(just, all_tokens, fl, ll, fc, lc, pattern, nth, ml, mr, sti
    let mr      = (empty(rest) ||
          \ (empty(rest) && stridx(after, a:mr) == 0)) ? '' : a:mr

+    " Adjust indentation of the lines starting with a delimiter
+    let lpad = ''
+    if nth == 0
+      let ipad = repeat(' ', min_indent - len(token.ml))
+      if mode ==? 'l'
+        let token = ipad . token
+      else
+        let lpad = ipad
+      endif
+    endif
+
    " Align the token
-    let aligned = join([token, ml, delim, mr, rpad], '')
+    let aligned = join([lpad, token, ml, dl, delim, dr, mr, rpad], '')
    let tokens[nth] = aligned

    " Update the line
-    let newline = substitute(before.join(tokens, '').after, '\s*$', '', '')
+    let newline = s:rtrim(before.join(tokens, '').after)
    call setline(line, newline)
  endfor

-  if a:recursive && a:nth < max_tokens
-    let just = a:recursive == 2 ? !a:just : a:just
-    call s:do_align(just, a:all_tokens, a:fl, a:ll, a:fc, a:lc, a:pattern,
-          \ a:nth + 1, a:ml, a:mr, a:stick_to_left, a:recursive)
+  if a:nth < max.tokens && (a:recur || len(a:modes) > 1)
+    call s:shift(a:modes, a:recur == 2)
+    call s:do_align(
+          \ a:modes, a:all_tokens, a:all_delims,
+          \ a:fl, a:ll, a:fc, a:lc, a:pattern,
+          \ a:nth + 1, a:ml, a:mr, a:da, a:indentation, a:stick_to_left,
+          \ a:ignore_unmatched, a:ignore_groups, a:recur)
  endif
 endfunction

-function! s:echon(l, n, d)
-  echon "\r"
-  echon "\rEasyAlign". s:just[a:l] ." (" .a:n.a:d. ")"
+function! s:input(str, default, vis)
+  if a:vis
+    normal! gv
+    redraw
+    execute "normal! \<esc>"
+  else
+    " EasyAlign command can be called without visual selection
+    redraw
+  endif
+  call inputsave()
+  let got = input(a:str, a:default)
+  call inputrestore()
+  try
+    return eval(got)
+  catch
+    return got
+  endtry
 endfunction

-function! easy_align#align(just, ...) range
-  let just      = a:just
-  let recursive = 0
-  let n         = ''
-  let ch        = ''
+function! s:interactive(modes, vis)
+  let mode = s:shift(a:modes, 1)
+  let n    = ''
+  let ch   = ''
+  let opts = {}
+  let vals = deepcopy(s:option_values)
+  let regx = 0

-  if a:0 == 0
-    while 1
-      call s:echon(just, n, '')
+  while 1
+    call s:echon(mode, n, '', opts)

-      let c  = getchar()
-      let ch = nr2char(c)
-      if c == 3 || c == 27 " CTRL-C / ESC
-        return
-      elseif c == '<27>kb' " Backspace
-        if len(n) > 0
-          let n = strpart(n, 0, len(n) - 1)
-        endif
-      elseif c == 13 " Enter key
-        let just = (just + 1) % len(s:just)
-      elseif ch == '-'
-        if empty(n)      | let n = '-'
-        elseif n == '-'  | let n = ''
-        else             | break
-        endif
-      elseif ch == '*'
-        if empty(n)      | let n = '*'
-        elseif n == '*'  | let n = '**'
-        elseif n == '**' | let n = ''
-        else             | break
-        endif
-      elseif c >= 48 && c <= 57 " Numbers
-        if n[0] == '*'   | break
-        else             | let n = n . ch
-        end
+    let c  = getchar()
+    let ch = nr2char(c)
+    if c == 3 || c == 27 " CTRL-C / ESC
+      throw 'exit'
+    elseif c == "\<bs>"
+      if len(n) > 0
+        let n = strpart(n, 0, len(n) - 1)
+      endif
+    elseif c == 13 " Enter key
+      let mode = s:shift(a:modes, 1)
+      if has_key(opts, 'm')
+        let opts.m = mode . strpart(opts.m, 1)
+      endif
+    elseif ch == '-'
+      if empty(n)      | let n = '-'
+      elseif n == '-'  | let n = ''
+      else             | break
+      endif
+    elseif ch == '*'
+      if empty(n)      | let n = '*'
+      elseif n == '*'  | let n = '**'
+      elseif n == '**' | let n = ''
+      else             | break
+      endif
+    elseif c >= 48 && c <= 57 " Numbers
+      if n[0] == '*'   | break
+      else             | let n = n . ch
+      end
+    elseif ch == "\<C-D>"
+      let opts['da'] = s:shift(vals['delimiter_align'], 1)
+    elseif ch == "\<C-I>"
+      let opts['idt'] = s:shift(vals['indentation'], 1)
+    elseif ch == "\<C-L>"
+      let opts['lm'] = s:input("Left margin: ", get(opts, 'lm', ''), a:vis)
+    elseif ch == "\<C-R>"
+      let opts['rm'] = s:input("Right margin: ", get(opts, 'rm', ''), a:vis)
+    elseif ch == "\<C-U>"
+      let opts['iu'] = s:shift(vals['ignore_unmatched'], 1)
+    elseif ch == "\<C-G>"
+      let opts['ig'] = s:shift(vals['ignore_groups'], 1)
+    elseif c == "\<Left>"
+      let opts['stl'] = 1
+      let opts['lm']  = 0
+    elseif c == "\<Right>"
+      let opts['stl'] = 0
+      let opts['lm']  = 1
+    elseif c == "\<Up>" || c == "\<Down>"
+      silent! call remove(opts, 'stl')
+      silent! call remove(opts, 'lm')
+    elseif ch == "\<C-O>"
+      let modes = tolower(s:input("Mode sequence: ", get(opts, 'm', mode), a:vis))
+      if match(modes, '^[lrc]\+\*\{0,2}$') != -1
+        let opts['m'] = modes
+        let mode      = modes[0]
+        while mode != s:shift(a:modes, 1)
+        endwhile
      else
+        silent! call remove(opts, 'm')
+      endif
+    elseif ch == "\<C-_>" || ch == "\<C-X>"
+      let ch = s:input('Regular expression: ', '', a:vis)
+      if !empty(ch)
+        let regx = 1
        break
      endif
-    endwhile
-  elseif a:0 == 1
-    let tokens = matchlist(a:1, '^\([1-9][0-9]*\|-[0-9]*\|\*\*\?\)\?\(.\)$')
-    if empty(tokens)
-      echo "Invalid arguments: ". a:1
-      return
+    else
+      break
    endif
-    let [n, ch] = tokens[1:2]
-  elseif a:0 == 2
-    let [n, ch] = a:000
+  endwhile
+  return [mode, n, ch, opts, s:normalize_options(opts), regx]
+endfunction
+
+function! s:parse_args(args)
+  let n    = ''
+  let ch   = ''
+  let args = a:args
+  let cand = ''
+  let opts = {}
+
+  " Poor man's option parser
+  let idx = 0
+  while 1
+    let midx = match(args, '\s*{.*}\s*$', idx)
+    if midx == -1 | break | endif
+
+    let cand = strpart(args, midx)
+    try
+      let [l, r, c, k, s, d, n] = ['l', 'r', 'c', 'k', 's', 'd', 'n']
+      let [L, R, C, K, S, D, N] = ['l', 'r', 'c', 'k', 's', 'd', 'n']
+      let o = eval(cand)
+      if type(o) == 4
+        let opts = o
+        if args[midx - 1 : midx] == '\ '
+          let midx += 1
+        endif
+        let args = strpart(args, 0, midx)
+        break
+      endif
+    catch
+      " Ignore
+    endtry
+    let idx = midx + 1
+  endwhile
+
+  " Invalid option dictionary
+  if len(substitute(cand, '\s', '', 'g')) > 2 && empty(opts)
+    call s:exit("Invalid option: ". cand)
  else
-    echo "Invalid number of arguments: ". a:0 ." (expected 0, 1, or 2)"
-    return
+    let opts = s:normalize_options(opts)
  endif

-  if n == '*'      | let [nth, recursive] = [1, 1]
-  elseif n == '**' | let [nth, recursive] = [1, 2]
+  " Has /Regexp/?
+  let matches = matchlist(args, '^\(.\{-}\)\s*/\(.*\)/\s*$')
+
+  " Found regexp
+  if !empty(matches)
+    let regexp = matches[2]
+    " Test regexp
+    try   | call matchlist('', regexp)
+    catch | call s:exit("Invalid regular expression: ". regexp)
+    endtry
+    return [matches[1], regexp, opts, 1]
+  else
+    let tokens = matchlist(args, '^\([1-9][0-9]*\|-[0-9]*\|\*\*\?\)\?\s*\(.\{-}\)\?$')
+    return [tokens[1], tokens[2], opts, 0]
+  endif
+endfunction
+
+function! easy_align#align(bang, expr) range
+  let modes  = get(g:,
+        \ (a:bang ? 'easy_align_bang_interactive_modes' : 'easy_align_interactive_modes'),
+        \ (a:bang ? ['r', 'l', 'c'] : ['l', 'r', 'c']))
+  let mode   = modes[0]
+  let recur  = 0
+  let n      = ''
+  let ch     = ''
+  let opts   = {}
+  let ioptsr = {}
+  let iopts  = {}
+  let regexp = 0
+  " Heuristically determine if the user was in visual mode
+  let vis    = a:firstline == line("'<") && a:lastline == line("'>")
+
+  try
+    if empty(a:expr)
+      let [mode, n, ch, ioptsr, iopts, regexp] = s:interactive(copy(modes), vis)
+    else
+      let [n, ch, opts, regexp] = s:parse_args(a:expr)
+      if empty(n) && empty(ch)
+        let [mode, n, ch, ioptsr, iopts, regexp] = s:interactive(copy(modes), vis)
+      elseif empty(ch)
+        " Try swapping n and ch
+        let [n, ch] = ['', n]
+      endif
+    endif
+  catch 'exit'
+    return
+  endtry
+
+  if n == '*'      | let [nth, recur] = [1, 1]
+  elseif n == '**' | let [nth, recur] = [1, 2]
  elseif n == '-'  | let nth = -1
  elseif empty(n)  | let nth = 1
  elseif n == '0' || ( n != '-0' && n != string(str2nr(n)) )
@@ -289,19 +685,74 @@ function! easy_align#align(just, ...) range
    let delimiters = extend(copy(delimiters), g:easy_align_delimiters)
  endif

-  if has_key(delimiters, ch)
-    let dict = delimiters[ch]
-    call s:do_align(just, {}, a:firstline, a:lastline,
-                  \ visualmode() == '' ? min([col("'<"), col("'>")]) : 1,
-                  \ visualmode() == '' ? max([col("'<"), col("'>")]) : 0,
-                  \ get(dict, 'pattern', ch),
-                  \ nth,
-                  \ get(dict, 'margin_left', ' '),
-                  \ get(dict, 'margin_right', ' '),
-                  \ get(dict, 'stick_to_left', 0), recursive)
-    call s:echon(just, n, ch)
+  if regexp
+    let dict = { 'pattern': ch }
  else
-    echon "\rUnknown delimiter: ". ch
+    " Resolving command-line ambiguity
+    if !empty(a:expr)
+      " '\ ' => ' '
+      if ch =~ '^\\\s\+$'
+        let ch = ' '
+      " '\\' => '\'
+      elseif ch =~ '^\\\\\s*$'
+        let ch = '\'
+      endif
+    endif
+    if !has_key(delimiters, ch)
+      echon "\rUnknown delimiter key: ". ch
+      return
+    endif
+    let dict = delimiters[ch]
  endif
+
+  for opt in [opts, iopts]
+    if !empty(opt)
+      let dict = extend(copy(dict), opt)
+    endif
+  endfor
+
+  let ml = get(dict, 'left_margin', ' ')
+  let mr = get(dict, 'right_margin', ' ')
+  if type(ml) == 0 | let ml = repeat(' ', ml) | endif
+  if type(mr) == 0 | let mr = repeat(' ', mr) | endif
+
+  let bvisual = vis && char2nr(visualmode()) == 22 " ^V
+
+  if recur && bvisual
+    echon "\rRecursive alignment is currently not supported in blockwise-visual mode"
+    return
+  endif
+
+  let aseq = get(dict, 'mode_sequence',
+        \ recur == 2 ? (mode ==? 'r' ? ['r', 'l'] : ['l', 'r']) : [mode])
+  let mode_expansion = matchstr(aseq, '\*\+$')
+  if mode_expansion == '*'
+    let aseq = aseq[0 : -2]
+    let recur = 1
+  elseif mode_expansion == '**'
+    let aseq = aseq[0 : -3]
+    let recur = 2
+  endif
+  let aseq_list = type(aseq) == 1 ? split(tolower(aseq), '\s*') : map(copy(aseq), 'tolower(v:val)')
+
+  try
+    call s:do_align(
+    \ aseq_list,
+    \ {}, {}, a:firstline, a:lastline,
+    \ bvisual ? min([col("'<"), col("'>")]) : 1,
+    \ bvisual ? max([col("'<"), col("'>")]) : 0,
+    \ get(dict, 'pattern', ch),
+    \ nth,
+    \ ml,
+    \ mr,
+    \ get(dict, 'delimiter_align', get(g:, 'easy_align_delimiter_align', 'r'))[0],
+    \ get(dict, 'indentation', get(g:, 'easy_align_indentation', 'k'))[0],
+    \ get(dict, 'stick_to_left', 0),
+    \ get(dict, 'ignore_unmatched', get(g:, 'easy_align_ignore_unmatched', 1)),
+    \ get(dict, 'ignore_groups', get(dict, 'ignores', s:ignored_syntax())),
+    \ recur)
+    call s:echon(mode, n, regexp ? '/'.ch.'/' : ch, ioptsr)
+  catch 'exit'
+  endtry
 endfunction

--- a/doc/easy_align.txt
+++ b/doc/easy_align.txt
@@ -1,35 +1,50 @@
+*easy_align.txt*  A simple, easy-to-use Vim alignment plugin
+
 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                                      *:EasyAlign* *:EasyAlign!*
 -------------------------------------------------------------------------

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

-For convenience, it is advised that you define a mapping for triggering it
-in your `.vimrc`.
+| Mode                      | Command                                        |
+| ------------------------- | ---------------------------------------------- |
+| Interactive mode          | :EasyAlign[!] [OPTIONS]                        |
+| Using predefined rules    | :EasyAlign[!] [FIELD#] DELIMITER_KEY [OPTIONS] |
+| Using regular expressions | :EasyAlign[!] [FIELD#] /REGEXP/ [OPTIONS]      |
+
+
+Interactive mode
+-------------------------------------------------------------------------
+
+The command will go into the interactive mode when no argument is given.
+For convenience, it is advised that you define a mapping for triggering it in
+your `.vimrc`.

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

-With this mapping, you can align selected lines with a few keystrokes.
+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)
+2. Optional Enter keys to select alignment mode (left, right, or center)
 3. Optional field number (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
@@ -37,7 +52,10 @@ With this mapping, you can align selected lines with a few keystrokes.
    ,        Multi-line method arguments. CSV.
    |        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:

@@ -50,24 +68,136 @@ 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


-EasyAlignRight                                           *EasyAlignRight*
+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 }     |
+
+
+Non-interactive mode
 -------------------------------------------------------------------------

-EasyAlignRight is the right-justified version of EasyAlign command.
+Instead of going into the interactive mode, you can type in arguments to
+`:EasyAlign` command.
+
+    " Using predefined alignment rules
+    :EasyAlign[!] [FIELD#] DELIMITER_KEY [OPTIONS]
+
+    " Using arbitrary regular expressions
+    :EasyAlign[!] [FIELD#] /REGEXP/ [OPTIONS]
+
+For example, when aligning the following lines around colons and semi-colons,
+
+    apple;:banana::cake
+    data;;exchange:;format
+
+try these commands:
+
+- :EasyAlign /[:;]\+/
+- :EasyAlign 2/[:;]\+/
+- :EasyAlign */[:;]\+/
+- :EasyAlign **/[:;]\+/
+
+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.
+
+- :EasyAlign * /[:;]\+/ { 'stick_to_left': 1, 'left_margin': 0 }
+
+Then we get:
+
+    apple;: banana::   cake
+    data;;  exchange:; format
+
+Option names are fuzzy-matched, so you can write as follows:
+
+- :EasyAlign * /[:;]\+/ { 'stl': 1, 'l': '' }
+
+You can even omit spaces between the arguments, so concisely (or cryptically):
+
+- :EasyAlign*/[:;]\+/{'s':1,'l':''}
+
+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                       |
+| ---------------- | ---------------- | ----------------------------- |
+| 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 field number 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 a dictionary argument to :EasyAlign command
+4. Option values can be set in interactive mode using special shortcut keys
+
+| Option           | Shortcut key        | Global variable                 |
+| ---------------- | ------------------- | ------------------------------- |
+| left_margin      | CTRL-L              |                                 |
+| right_margin     | CTRL-R              |                                 |
+| stick_to_left    | <Left>, <Right>     |                                 |
+| ignore_groups    | CTRL-G              | `g:easy_align_ignore_groups`      |
+| ignore_unmatched | CTRL-U              | `g:easy_align_ignore_unmatched`   |
+| indentation      | CTRL-I              | `g:easy_align_indentation`        |
+| delimiter_align  | CTRL-D              | `g:easy_align_delimiter_align`    |
+| mode_sequence    | CTRL-O              |                                 |
+
+
+Ignoring delimiters in comments or strings   *g:easy_align_ignore_groups*
 -------------------------------------------------------------------------

 EasyAlign can be configured to ignore delimiters in certain syntax
@@ -77,7 +207,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

@@ -90,7 +220,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
@@ -103,12 +233,15 @@ becomes as follows on `<Enter>:`

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

-You can change the default rule by defining `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:{'is':[]}

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

    {
      # Quantity of apples:  1
@@ -120,11 +253,11 @@ Then you get,
    }


-Handling unmatched lines                  *g:easy_align_ignore_unmatched*
+Ignoring unmatched lines                  *g:easy_align_ignore_unmatched*
 -------------------------------------------------------------------------

 Lines without any matching delimiter are ignored as well (except in
-right-justification mode).
+right-align mode).

 For example, when aligning the following code block around the colons,

@@ -146,9 +279,14 @@ this is usually what we want.
      grapefruits: 3
    }

-However, this default behavior is also configurable.
+However, this default behavior is also configurable by using one of these 4
+methods.

-    let g:easy_align_ignore_unmatched = 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:{'iu':0}

 Then we get,

@@ -161,23 +299,188 @@ 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
+lengths are aligned.
+
+    apple = 1
+    banana += apple
+    cake ||= banana
+
+By default, delimiters are right-aligned as follows.
+
+    apple    = 1
+    banana  += apple
+    cake   ||= banana
+
+However, with ':EasyAlign={'da':l}', delimiters are left-aligned.
+
+    apple  =   1
+    banana +=  apple
+    cake   ||= banana
+
+And on ':EasyAlign={'da':c}', 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={'idt':s}
+      apple    = 1
+      banana   = 2
+      cake     = 3
+      daisy    = 4
+      eggplant = 5
+
+    # Use the _d_eepest indentation among the lines
+    #   :EasyAlign={'idt':d}
+            apple    = 1
+            banana   = 2
+            cake     = 3
+            daisy    = 4
+            eggplant = 5
+
+    # Indentation: _n_one
+    #   :EasyAlign={'idt':n}
+    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.
+
+
+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']
+
+
+Alignments over multiple occurrences of delimiters
+-------------------------------------------------------------------------
+
+As stated above, "field number" 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' }
+
+    " Right, left, center alignment over the 2nd to 4th occurrences of delimiters
+    :EasyAlign 2={ 'm': 'rlc' }
+
+    " (*) Repeating alignments (default: l, r, or c)
+    "   Right, left, center, center, center, center, ...
+    :EasyAlign *={ 'm': 'rlc' }
+
+    " (**) Alternating alignments (default: lr or rl)
+    "   Right, left, center, right, left, center, ...
+    :EasyAlign **={ 'm': 'rlc' }
+
+    " Right, left, center, center, center, ... repeating alignment
+    " over the 3rd to the last occurrences of delimiters
+    :EasyAlign 3={ 'm': 'rlc*' }
+
+    " Right, left, center, right, left, center, ... alternating alignment
+    " over the 3rd to the last occurrences of delimiters
+    :EasyAlign 3={ 'm': 'rlc**' }
+
+
 Extending alignment rules                       *g:easy_align_delimiters*
 -------------------------------------------------------------------------

+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`.
+
    let g:easy_align_delimiters = {
    \ '>': { 'pattern': '>>\|=>\|>' },
-    \ '/': { 'pattern': '//\+' },
-    \ '#': { 'pattern': '#\+' },
+    \ '/': { 'pattern': '//\+\|/\*\|\*/', 'ignore_groups': ['String'] },
+    \ '#': { 'pattern': '#\+', 'ignore_groups': ['String'] },
    \ ']': {
-    \     'pattern':       '[\[\]]',
-    \     'margin_left':   '',
-    \     'margin_right':  '',
+    \     'pattern':       '[[\]]',
+    \     'left_margin':   0,
+    \     'right_margin':  0,
    \     'stick_to_left': 0
    \   },
    \ ')': {
    \     'pattern':       '[()]',
-    \     'margin_left':   '',
-    \     'margin_right':  '',
+    \     'left_margin':   0,
+    \     'right_margin':  0,
    \     'stick_to_left': 0
    \   }
    \ }
--- a/plugin/easy_align.vim
+++ b/plugin/easy_align.vim
@@ -26,5 +26,4 @@ if exists("g:loaded_easy_align_plugin")
 endif
 let g:loaded_easy_align_plugin = 1

-command! -nargs=* -range EasyAlign <line1>,<line2>call easy_align#align(0, <f-args>)
-command! -nargs=* -range EasyAlignRight <line1>,<line2>call easy_align#align(1, <f-args>)
+command! -nargs=* -range -bang EasyAlign <line1>,<line2>call easy_align#align('<bang>' == '!', <q-args>)
--- a/test/basic.expected
+++ b/test/basic.expected
--- a/test/basic.md
+++ b/test/basic.md
@@ -0,0 +1,273 @@
+" :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 = #
+eeee === eee = eee = eee=f
+fff = ggg += gg &&= gg
+g != hhhhhhhh == # 8
+i   := 5
+i     %= 5
+i       *= 5
+j     =~ 5
+j   >= 5
+aa      =>         123
+aa <<= 123
+aa        >>= 123
+bbb               => 123
+c     => 1233123
+d   =>      123
+dddddd &&= 123
+dddddd ||= 123
+dddddd /= 123
+gg <=> ee
+
+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
+
+...-.-----
+..--..----
+.---...---
+----....--
+.---.....-
+..--......
+...-.....-
+
+  apple = 1
+    banana = 2
+      cake = 3
+        daisy = 4
+     eggplant = 5
+
+
+```c
+
+int a = 1;
+long b = 2;
+float c = 3;
+string d = 4;
+// this line should not get aligned
+long int e = 5;
+std::map f;
+std::map g; /* this? */
+short h /* how about this? */ = 6;
+string i = "asdf";
+
+```
+
+```ruby
+
+a =
+a = 1
+bbbb .= 2
+ccccccc = 3
+ccccccccccccccc
+# eeeeeeeeeeeeeeee
+e # asdf
+ddd = #
+eeee === eee = eee = eee=f
+fff = ggg += gg &&= gg
+g != hhhhhhhh == # 8
+i   := 5
+i     %= 5
+i       *= 5
+j     =~ 5
+j   >= 5
+aa      =>         123
+aa <<= 123
+aa        >>= 123
+bbb               => 123
+c     => 1233123
+d   =>      123
+dddddd &&= 123
+dddddd ||= 123
+dddddd /= 123
+gg <=> ee
+
+a = 1
+bb = 22
+ccc = 333
+dddd = "asdf"
+
+```
+
+a a a a a
+bbb bbb bbb bbb bbb
+ccccc ccccc ccccc ccccc ccccc
+  d ddd dddd ddd d
+
+aaaaa = 123456778901234567890 =
+bbbbbbbbbb = 12345 =
+
+aaaaa = 123456778901234567890 =
+cccccccccccccccccc = 123 =
+
+aaaaa = 123456778901234567890 =
+cccccccccccccccccc = 12345678 =
+
+aaaaa = 12345 =
+bbbbbbbbbb = 123456778901234567890       =
+
+aaaaa =             12345
+bbbbbbbbbb = 123456778901234567890
+
+123456 789
+1234567890 1
+
+1234 56
+123456 7890
+
+ aaaaa = 123456778901234567890 =
+     cccccccccccccccccc =       12345678 =
+
+```
+ aaaaa =   123456778901234567890 =
+cccccccccccccccccc =12345678 =
+
+            aaaa             = 123456778901234567890 =
+     cccccccccccccccccc      = 12345678 =
+
+            aaaaaaaaaaaaa = 123456778901234567890 =
+cc = 12345678 =
+
+           aaaaaaaaaaa= 123
+                       a = 123
+
+           aaaaaaaaaaaa= 123
+                       a = 123
+
+         aaaaaaaaaaaa = 123
+       aaaaaaaaaaa = 123
+      aaaaaaaaaa  = 123
+     aaa     = 123
+    aa      = 123
+   a      = 123
+
+            aaaa = 123456778901234567890 =
+cccccccccccccc = 12345678 =
+
+              aaaa = 123456778901234567890 =
+               bbbbbb = 4
+cccccccccccccccccc = 12345678 =
+
+                    aaaa = 123456778901234567890 =
+     cccccccccccccccccc = 12345678 =
+
+                    aaaaa                     = 123456778901234567890 =
+                     cc                       = 12345678 =
+
+=aaaaa = 123456778901234567890 =
+=    cccccccccccccccccc = 12345678 =
+
+```
+
+a,,bbb
+aa,,bb
+aaa,,b
+aaaa,,
+aaa,b,
+aa,bb,
+a,bbb,
+
+1 22222 33 444 555 6666 7 888
+11 222 3333 4 55 6666 77 888
+111 22 333 444 55555 6666 7 88888
+1111 2 33 444 555 66 777 8
+
--- a/test/basic.script
+++ b/test/basic.script
@@ -0,0 +1 @@
+4Gvipjyvip
--- a/test/regexp.expected
+++ b/test/regexp.expected
@@ -0,0 +1,96 @@
+" :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
@@ -0,0 +1,12 @@
+" :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
@@ -0,0 +1 @@
+4Gvipjyvip:EasyAlign:
--- a/test/run.vim
+++ b/test/run.vim
@@ -0,0 +1,51 @@
+e!
+
+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
+set colorcolumn=
+
+silent! ScrollPositionHide
+
+call GFM()
+
+normal gg
+let @b=system('cat '. expand('%:p:r') . '.script')
+let @a='@b:vert diffsplit ' . expand('%:p:r') . '.expected
+'
Author	SHA1	Message	Date
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
Junegunn Choi	aad5012615	Allow whitespaces between delimiter key and options	2013-08-13 20:38:23 +09:00
Junegunn Choi	0166077e16	Case-insensitive match of `delimiter_align`	2013-08-13 00:19:56 +09:00
Junegunn Choi	3c4b7af9b5	Update EXAMPLES.md	2013-08-13 00:10:42 +09:00
Junegunn Choi	5e6e60d620	Add `delimiter_align` option	2013-08-12 20:33:04 +09:00
Junegunn Choi	712bab8c72	Allow zero-width matches	2013-08-12 11:58:52 +09:00
Junegunn Choi	0546969c6b	Update g:easy_align_delimiters example in README	2013-08-12 01:58:31 +09:00
Junegunn Choi	8805ec3834	Update EXAMPLES.md	2013-08-12 01:57:15 +09:00
Junegunn Choi	96608ee5ef	Update EXAMPLES.md	2013-08-12 01:56:08 +09:00
Junegunn Choi	7d031956ab	Fix regression: lines with indentation	2013-08-12 01:47:05 +09:00
Junegunn Choi	c4dbfece32	Disallow recursive alignment in blockwise-visual mode	2013-08-12 01:34:14 +09:00
Junegunn Choi	a2811dc253	Add a proper support for \@=	2013-08-12 00:54:34 +09:00
Junegunn Choi	5e4ec85956	Update EXAMPLES.md	2013-08-11 03:07:37 +09:00
Junegunn Choi	b3281fb19a	Allow matching preceding atom with zero-width (\@=)	2013-08-11 02:33:22 +09:00
Junegunn Choi	10a4176159	Update README	2013-08-09 18:19:05 +09:00
Junegunn Choi	edba1827ed	Update doc	2013-08-07 00:30:34 +09:00
Junegunn Choi	1cf343a271	Workaround for E706 - Avoid E706 error - Fix not to skip comment/string lines when ignore_unmatched is 0	2013-08-06 00:42:08 +09:00
Junegunn Choi	c66f35ad39	Disallow pattern option	2013-08-05 23:51:29 +09:00
Junegunn Choi	2486b9c6df	Usability improvements - Preserve indentation when a line starts with a delimiter - Useful for aligning multi-line method chains - Renamed `margin_{left,right}` to `{left,right}_margin - Makes it easier to type in (`l`, `r`) - `margin_{left,right}` is still supported - Margins can be specified as the number of spaces, or as an arbitrary string	2013-08-05 23:41:31 +09:00
Junegunn Choi	20124bc622	`{\s\+}` is a valid empty option	2013-08-05 02:15:02 +09:00
Junegunn Choi	2a2625014b	Update README	2013-08-05 00:45:33 +09:00
Junegunn Choi	375da6858a	Update README	2013-08-04 18:38:21 +09:00
Junegunn Choi	06d5bcb911	Rename :EasyAlignRight to :EasyAlign!	2013-08-04 18:04:56 +09:00
Junegunn Choi	badb701721	Exclude test files from export	2013-08-04 17:52:10 +09:00
Junegunn Choi	ea84b43062	Update doc	2013-08-04 11:28:34 +09:00
Junegunn Choi	bd8327499a	Add support for arbitrary regular expressions	2013-08-04 11:22:40 +09:00
Junegunn Choi	057be51067	Left-align delimiters of different lengths when stick_to_left is set	2013-08-03 01:09:21 +09:00
Junegunn Choi	6d841110af	Allow rule-wise configuration of `ignores` and `ignore_unmatched`	2013-08-02 12:21:55 +09:00
Junegunn Choi	ec456f82a6	Update .gitattributes	2013-08-01 23:49:26 +09:00