Allow whitespaces between delimiter key and options

- Avoid E706 error
- Fix not to skip comment/string lines when ignore_unmatched is 0

.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

EXAMPLES.md

@@ -1,33 +1,49 @@
-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>`
+
+### Example
+
 ```
 
 Paul McCartney 1942
@@ -37,10 +53,19 @@ Pete Best 1941
 
 ```
 
-
 Formatting table
 ----------------
 
+Try these commands:
+- `<Enter>*|`
+- `<Enter>**|`
+- `<Enter><Enter>*|`
+- `<Enter><Enter>**|`
+
+### Example
+
+```
+
 | Option| Type | Default | Description |
 |--|--|--|--|
 | threads | Fixnum | 1 | number of threads in the thread pool |
@@ -51,10 +76,23 @@ 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>**=`
+
+### Example
+
 ```ruby
 
 a =
@@ -87,50 +125,269 @@ 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
+  # 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:r00t
-
+  "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': '#', 'ignores': ['String'] } }
+```
+
+Notice that the rule overrides `ignores` 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': '#', 'ignores': ['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;
 ```
 

README.md

@@ -3,20 +3,23 @@ vim-easy-align
 
 A simple, easy-to-use Vim alignment plugin without too much ambition.
 
-Features:
-
-- Optimized for code editing
-- Requires minimal keystrokes
-- Extensible alignment rules
-- Aligns text around either _all or n-th_ occurrence(s) of the delimiter
-- Ignores delimiters in certain syntax highlighting groups (e.g. comments, strings)
-- Ignores lines without a matching delimiter
-
 Demo
 ----
 
 ![Screencast](https://raw.github.com/junegunn/vim-easy-align/gif/vim-easy-align.gif)
 
+Features
+--------
+
+- Makes the common case easy
+  - Comes with a predefined set of alignment rules
+  - Provides a fast and intuitive interface
+- Extensible
+  - You can define your own rules
+  - Supports arbitrary regular expressions
+- Optimized for code editing
+  - Takes advantage of syntax highlighting feature to avoid unwanted alignments
+
 Installation
 ------------
 
@@ -26,21 +29,37 @@ or [Pathogen](https://github.com/tpope/vim-pathogen).
 
 ### 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.
-For convenience, it is advised that you define a mapping for triggering it in your `.vimrc`.
+_vim-easy-align_ defines `:EasyAlign` command (and the right-justification
+variant `:EasyAlign!`) in the visual mode.
+
+| Mode                      | Command                                       |
+| ------------------------- | --------------------------------------------- |
+| Interactive mode          | `:EasyAlign`                                  |
+| 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`.
 
 ```vim
 vnoremap <silent> <Enter> :EasyAlign<cr>
 ```
 
-With the mapping, you can align selected lines with a few keystrokes.
+With the mapping, you can align selected lines of text with only a few keystrokes.
 
 1. `<Enter>` key to start interactive EasyAlign command
 1. Optional Enter keys to toggle right-justification mode
@@ -57,31 +76,78 @@ 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
+#### Example command sequences
 
-| With visual map     | Description                                              | Equivalent command        |
-| ------------------- | -------------------------------------------------------- | ------------------------- |
-| `<Enter><space>`    | Alignment around 1st whitespaces                         | `:'<,'>EasyAlign\ `       |
-| `<Enter>2<space>`   | Alignment around 2nd whitespaces                         | `:'<,'>EasyAlign2\ `      |
-| `<Enter>-<space>`   | Alignment around the last whitespaces                    | `:'<,'>EasyAlign-\ `      |
-| `<Enter>:`          | Alignment around 1st colon                               | `:'<,'>EasyAlign:`        |
-| `<Enter>=`          | Alignment around 1st equals signs (and the likes)        | `:'<,'>EasyAlign=`        |
-| `<Enter>2=`         | Alignment around 2nd equals signs (and the likes)        | `:'<,'>EasyAlign2=`       |
-| `<Enter>3=`         | Alignment around 3rd equals signs (and the likes)        | `:'<,'>EasyAlign3=`       |
-| `<Enter>*=`         | Alignment around all equals signs (and the likes)        | `:'<,'>EasyAlign*=`       |
-| `<Enter>**=`        | Left-right alternating alignment around all equals signs | `:'<,'>EasyAlign**=`      |
-| `<Enter><Enter>=`   | Right-justified alignment around 1st equals signs        | `:'<,'>EasyAlignRight=`   |
-| `<Enter><Enter>**=` | Right-left alternating alignment around all equals signs | `:'<,'>EasyAlignRight**=` |
-| ...                 | ...                                                      |                           |
+| With visual map     | Description                                              | Equivalent command    |
+| ------------------- | -------------------------------------------------------- | --------------------- |
+| `<Enter><space>`    | Alignment around 1st whitespaces                         | `:'<,'>EasyAlign\ `   |
+| `<Enter>2<space>`   | Alignment around 2nd whitespaces                         | `:'<,'>EasyAlign2\ `  |
+| `<Enter>-<space>`   | Alignment around the last whitespaces                    | `:'<,'>EasyAlign-\ `  |
+| `<Enter>:`          | Alignment around 1st colon                               | `:'<,'>EasyAlign:`    |
+| `<Enter>=`          | Alignment around 1st equals signs (and the likes)        | `:'<,'>EasyAlign=`    |
+| `<Enter>2=`         | Alignment around 2nd equals signs (and the likes)        | `:'<,'>EasyAlign2=`   |
+| `<Enter>3=`         | Alignment around 3rd equals signs (and the likes)        | `:'<,'>EasyAlign3=`   |
+| `<Enter>*=`         | Alignment around all equals signs (and the likes)        | `:'<,'>EasyAlign*=`   |
+| `<Enter>**=`        | Left-right alternating alignment around all equals signs | `:'<,'>EasyAlign**=`  |
+| `<Enter><Enter>=`   | Right-justified alignment around 1st equals signs        | `:'<,'>EasyAlign!=`   |
+| `<Enter><Enter>**=` | Right-left alternating alignment around all equals signs | `:'<,'>EasyAlign!**=` |
+| ...                 | ...                                                      |                       |
+
+### Non-interactive mode
+
+Instead of going into the interactive mode, you can type in arguments to
+`:EasyAlign` command. In non-interactive mode, you can even use arbitrary
+regular expressions.
+
+```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': '' }`
+
+Then we get:
+
+    apple;: banana::   cake
+    data;;  exchange:; format
+
+Options keys 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}`
+
+Available options will be shown later in the document.
 
 ### Partial alignment in blockwise-visual mode
 
@@ -96,9 +162,9 @@ my_hash = { :a => 1,
             :aaa => 3 }
 ```
 
-In non-blockwise visual mode (`v` / `V`), `<Enter>=` won't work since the assignment
-operator in the first line gets in the way.
-So we instead enter blockwise-visual mode (`CTRL-V`), and select the text *around*
+In non-blockwise visual mode (`v` / `V`), `<Enter>=` won't work since the
+assignment operator in the first line gets in the way. So we instead enter
+blockwise-visual mode (`CTRL-V`), and select the text *around*
 `=>` operators, then press `<Enter>=`.
 
 ```ruby
@@ -110,20 +176,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 highlighting groups |
-| g:easy_align_ignore_unmatched | boolean    | `1`                   | Ignore lines without matching delimiter               |
-| g:easy_align_delimiters       | dictionary | `{}`                  | Extend or override alignment rules                    |
+Options values can be 1) specified as global variables, 2) set on each alignment
+rule in `g:easy_align_delimiters`, 3) or given to every `:EasyAlign` command.
+
+Command-line options have the highest precedence, and global variables have the
+lowest precedence.
+
+### List of options
+
+| Option             | Type              | Default                 | Description                                             |
+| ------------------ | ----------------- | ----------------------- | ------------------------------------------------------- |
+| `left_margin`      | number            | 0                       | Number of spaces to attach before delimiter             |
+| `left_margin`      | string            | `''`                    | String to attach before delimiter                       |
+| `right_margin`     | number            | 0                       | Number of spaces to attach after delimiter              |
+| `right_margin`     | string            | `''`                    | String to attach after delimiter                        |
+| `stick_to_left`    | boolean           | 0                       | Whether to position delimiter on the left-side          |
+| `ignore_unmatched` | boolean           | 1                       | Whether to ignore lines without matching delimiter      |
+| `ignores`          | array             | `['String', 'Comment']` | Delimiters in these syntax highlight groups are ignored |
+| `delimiter_align`  | string            | `r`                     | Determines how to align delimiters of different lengths |
+
+Some of the options can be specified using corresponding global variables.
+
+| Option             | Global variable                 |
+| ------------------ | ------------------------------- |
+| `ignore_unmatched` | `g:easy_align_ignore_unmatched` |
+| `ignores`          | `g:easy_align_ignores`          |
+| `delimiter_align`  | `g:easy_align_delimiter_align`  |
 
 ### Ignoring delimiters in comments or strings
 
-EasyAlign can be configured to ignore delimiters in certain highlight groups,
-such as code comments or strings. By default, delimiters that are highlighted as
-code comments or strings are ignored.
+EasyAlign can be configured to ignore delimiters in certain syntax highlight
+groups, such as code comments or strings. By default, delimiters that are
+highlighted as code comments or strings are ignored.
 
 ```vim
 " Default:
@@ -132,7 +219,7 @@ code comments or strings are ignored.
 let g:easy_align_ignores = ['Comment', 'String']
 ```
 
-For example,
+For example, the following paragraph
 
 ```ruby
 {
@@ -145,7 +232,7 @@ For example,
 }
 ```
 
-becomes
+becomes as follows on `<Enter>:` (or `:EasyAlign:`)
 
 ```ruby
 {
@@ -158,16 +245,15 @@ becomes
 }
 ```
 
-Naturally, this only works when syntax highlighting is enabled.
+Naturally, this feature only works when syntax highlighting is enabled.
 
-You can override `g:easy_align_ignores` to change the rule.
+You can change the default rule by using one of these 3 methods.
 
-```vim
-" Ignore nothing!
-let g:easy_align_ignores = []
-```
+1. Define global `g:easy_align_ignores` list
+2. Define a custom alignment rule in `g:easy_align_delimiters` with `ignores` option
+3. Provide `ignores` option to `:EasyAlign` command. e.g. `:EasyAlign:{'is':[]}`
 
-Then you get,
+For example if you set `ignores` option to be an empty list, you get
 
 ```ruby
 {
@@ -184,7 +270,7 @@ Satisfied? :satisfied:
 
 ### Ignoring unmatched lines
 
-Lines without a matching delimiter are ignored as well (except in
+Lines without any matching delimiter are ignored as well (except in
 right-justification mode).
 
 For example, when aligning the following code block around the colons,
@@ -211,11 +297,12 @@ 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 3
+methods.
 
-```vim
-let g:easy_align_ignore_unmatched = 0
-```
+1. Set the global `g:easy_align_ignore_unmatched` variable to 0
+2. Define a custom alignment rule with `ignore_unmatched` option set to 0
+3. Provide `ignore_unmatched` option to `:EasyAlign` command. e.g. `:EasyAlign:{'iu':0}`
 
 Then we get,
 
@@ -229,29 +316,80 @@ Then we get,
 }
 ```
 
+### 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
+```
+
 ### 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': '//\+\|/\*\|\*/', 'ignores': ['String'] },
+\ '#': { 'pattern': '#\+', 'ignores': ['String'], 'delimiter_align': 'l' },
 \ ']': {
 \     'pattern':       '[\[\]]',
-\     'margin_left':   '',
-\     'margin_right':  '',
+\     '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.
+
 Author
 ------
 

autoload/easy_align.vim

@@ -27,20 +27,26 @@ endif
 let g:loaded_easy_align = 1
 
 let s:easy_align_delimiters_default = {
-\  ' ': { 'pattern': ' ',  'margin_left': '',  'margin_right': '',  'stick_to_left': 0 },
+\  ' ': { 'pattern': ' ',  'left_margin': '',  'right_margin': '',  '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 },
+\                          'left_margin': ' ', 'right_margin': ' ', 'stick_to_left': 0 },
+\  ':': { 'pattern': ':',  'left_margin': '',  'right_margin': ' ', 'stick_to_left': 1 },
+\  ',': { 'pattern': ',',  'left_margin': '',  'right_margin': ' ', 'stick_to_left': 1 },
+\  '|': { 'pattern': '|',  'left_margin': ' ', 'right_margin': ' ', 'stick_to_left': 0 },
+\  '.': { 'pattern': '\.', 'left_margin': '',  'right_margin': '',  'stick_to_left': 0 },
 \  '{': { 'pattern': '(\@<!{',
-\                          'margin_left': ' ', 'margin_right': ' ', 'stick_to_left': 0 },
-\  '}': { 'pattern': '}',  'margin_left': ' ', 'margin_right': '',  'stick_to_left': 0 }
+\                          'left_margin': ' ', 'right_margin': ' ', 'stick_to_left': 0 },
+\  '}': { 'pattern': '}',  'left_margin': ' ', 'right_margin': '',  'stick_to_left': 0 }
 \ }
 
 let s:just = ['', '[R]']
 
+let s:known_options = {
+\ 'margin_left': [0, 1], 'margin_right': [0, 1], 'stick_to_left': [0],
+\ 'left_margin': [0, 1], 'right_margin': [0, 1],
+\ 'ignores': [3], 'ignore_unmatched': [0], 'delimiter_align': [1]
+\ }
+
 if exists("*strwidth")
   function! s:strwidth(str)
     return strwidth(a:str)
@@ -73,49 +79,146 @@ function! s:ignored_syntax()
   endif
 endfunction
 
-function! s:do_align(just, all_tokens, fl, ll, fc, lc, pattern, nth, ml, mr, stick_to_left, recursive)
+function! s:echon(l, n, d)
+  echon "\r"
+  echon "\rEasyAlign". s:just[a:l] ." (" .a:n.a:d. ")"
+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:fuzzy_lu(key)
+  if has_key(s:known_options, a:key)
+    return a:key
+  endif
+
+  let regexp  = '^' . substitute(substitute(a:key, '-', '_', 'g'), '\(.\)', '\1.*', 'g')
+  let matches = filter(keys(s:known_options), 'v:val =~ regexp')
+
+  if empty(matches)
+    call s:exit("Unknown option key: ". a:key)
+  elseif len(matches) == 1
+    return matches[0]
+  else
+    call s:exit("Ambiguous option key: ". a:key ." (" .join(matches, ', '). ")")
+  endif
+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, fc, lc, pattern, stick_to_left, ignore_unmatched, ignores)
+  let left    = 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(left, pattern, idx)
+    if empty(matches) | break | endif
+    if empty(matches[1])
+      let char = strpart(left, idx, 1)
+      if empty(char) | break | endif
+      let [match, part, delim] = [char, char, '']
+    else
+      let [match, part, delim] = matches[1 : 3]
+    endif
+
+    let ignorable = s:highlighted_as(a:line, idx + len(part) + a:fc, a:ignores)
+    if ignorable
+      let token .= match
+    else
+      call add(tokens, token . match)
+      call add(delims, delim)
+      let token = ''
+    endif
+
+    let idx += len(match)
+  endwhile
+
+  let leftover = token . strpart(left, idx)
+  if !empty(leftover)
+    call add(tokens, leftover)
+    call add(delims, '')
+  endif
+
+  " 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)
+  endif
+
+  " Skip comment line
+  if ignorable && len(tokens) == 1 && a:ignore_unmatched
+    let tokens = []
+    let delims = []
+  endif
+
+  return [tokens, delims]
+endfunction
+
+function! s:do_align(just, all_tokens, all_delims, fl, ll, fc, lc, pattern, nth, ml, mr, da, stick_to_left, ignore_unmatched, ignores, 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()
+  let min_indent     = -1
 
   " 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')
-      if empty(ignored_syntax)
-        let tokens = raw_tokens
-      else
-        " Concat adjacent tokens that are split by ignorable delimiters
-        let tokens = []
-        let idx    = 0
-        let concat = 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
+      let [tokens, delims] = s:split_line(line, a:fc, a:lc, a:pattern, a:stick_to_left, a:ignore_unmatched, a:ignores)
 
       " 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
@@ -133,7 +236,7 @@ function! s:do_align(just, all_tokens, fl, ll, fc, lc, pattern, nth, ml, mr, sti
       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
+      if empty(delims[len(delims) - 1])
         let nth -= 1
       endif
 
@@ -142,15 +245,18 @@ 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:just == 0 && a:ignore_unmatched
       continue
     endif
 
+    let indent        = len(matchstr(tokens[0], '^\s\+'))
+    if min_indent < 0 || indent < min_indent
+      let min_indent  = indent
+    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 lines[line]   = [nth, prefix, token, delim]
@@ -159,11 +265,12 @@ function! s:do_align(just, all_tokens, fl, ll, fc, lc, pattern, nth, ml, mr, sti
   " 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
@@ -181,7 +288,17 @@ function! s:do_align(just, all_tokens, fl, ll, fc, lc, pattern, nth, ml, mr, sti
     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)
@@ -194,82 +311,152 @@ 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(strpart(before.token, '^\s\+').ml))
+      if a:just == 0
+        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)
+    call s:do_align(just, 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:stick_to_left, a:ignore_unmatched,
+          \ a:ignores, a:recursive)
   endif
 endfunction
 
-function! s:echon(l, n, d)
-  echon "\r"
-  echon "\rEasyAlign". s:just[a:l] ." (" .a:n.a:d. ")"
+function! s:interactive(just)
+  let just = a:just
+  let n    = ''
+  let ch   = ''
+
+  while 1
+    call s:echon(just, n, '')
+
+    let c  = getchar()
+    let ch = nr2char(c)
+    if c == 3 || c == 27 " CTRL-C / ESC
+      throw 'exit'
+    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
+    else
+      break
+    endif
+  endwhile
+  return [just, n, ch]
 endfunction
 
-function! easy_align#align(just, ...) range
-  let just      = a:just
-  let recursive = 0
-  let n         = ''
-  let ch        = ''
+function! s:parse_args(args)
+  let n      = ''
+  let ch     = ''
+  let args   = a:args
+  let cand   = ''
+  let option = {}
 
-  if a:0 == 0
-    while 1
-      call s:echon(just, n, '')
+  " Poor man's option parser
+  let idx = 0
+  while 1
+    let midx = match(args, '\s*{.*}\s*$', idx)
+    if midx == -1 | break | endif
 
-      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)
+    let cand = strpart(args, midx)
+    try
+      let [l, r, c] = ['l', 'r', 'c']
+      let [L, R, C] = ['l', 'r', 'c']
+      let o = eval(cand)
+      if type(o) == 4
+        let option = o
+        if args[midx - 1 : midx] == '\ '
+          let midx += 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
-      else
+        let args = strpart(args, 0, midx)
         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
-    endif
-    let [n, ch] = tokens[1:2]
-  elseif a:0 == 2
-    let [n, ch] = a:000
-  else
-    echo "Invalid number of arguments: ". a:0 ." (expected 0, 1, or 2)"
-    return
+    catch
+      " Ignore
+    endtry
+    let idx = midx + 1
+  endwhile
+
+  " Invalid option dictionary
+  if len(substitute(cand, '\s', '', 'g')) > 2 && empty(option)
+    call s:exit("Invalid option: ". cand)
   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, option, 1]
+  else
+    let tokens = matchlist(args, '^\([1-9][0-9]*\|-[0-9]*\|\*\*\?\)\?\s*\(.\{-}\)\?$')
+    return [tokens[1], tokens[2], option, 0]
+  endif
+endfunction
+
+function! easy_align#align(just, expr) range
+  let just   = a:just
+  let recur  = 0
+  let n      = ''
+  let ch     = ''
+  let option = {}
+  let regexp = 0
+
+  try
+    if empty(a:expr)
+      let [just, n, ch] = s:interactive(just)
+    else
+      let [n, ch, option, regexp] = s:parse_args(a:expr)
+      if 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)) )
@@ -284,19 +471,61 @@ 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
+
+  try
+    if !empty(option)
+      let dict = extend(copy(dict), s:normalize_options(option))
+    endif
+  catch 'exit'
+    return
+  endtry
+
+  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 = visualmode() == ''
+
+  if recur && bvisual
+    echon "\rRecursive alignment is currently not supported in blockwise-visual mode"
+    return
+  endif
+
+  try
+    call s:do_align(just, {}, {}, 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')),
+    \ get(dict, 'stick_to_left', 0),
+    \ get(dict, 'ignore_unmatched', get(g:, 'easy_align_ignore_unmatched', 1)),
+    \ get(dict, 'ignores', s:ignored_syntax()),
+    \ recur)
+    call s:echon(just, n, regexp ? '/'.ch.'/' : ch)
+  catch 'exit'
+  endtry
 endfunction
 

doc/easy_align.txt

@@ -1,3 +1,5 @@
+*easy_align.txt*  A simple, easy-to-use Vim alignment plugin
+
 vim-easy-align                              *vim-easy-align* *easy-align*
 =========================================================================
 
@@ -7,17 +9,29 @@ A simple, easy-to-use Vim alignment plugin without too much ambition.
   Source: https://github.com/junegunn/vim-easy-align
 
 
-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-justification version.)
 
-For convenience, it is advised that you define a mapping for triggering it
-in your `.vimrc`.
+| Mode                      | Command                                     |
+| ------------------------- | ------------------------------------------- |
+| Interactive mode          | :EasyAlign                                  |
+| 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)
@@ -54,10 +68,60 @@ Examples:
   <Enter><Enter>**=  Right-left alternating alignment around all equals signs
 
 
-EasyAlignRight                                           *EasyAlignRight*
+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. In non-interactive mode, you can even use arbitrary
+regular expressions.
+
+    " 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': '' }
+
+Then we get:
+
+    apple;: banana::   cake
+    data;;  exchange:; format
+
+Options keys 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':''}
+
+Available options are as follows.
+
+| Atrribute        | Type             | Default                 |
+| ---------------- | ---------------- | ----------------------- |
+| left_margin      | number or string | 0                       |
+| right_margin     | number or string | 0                       |
+| stick_to_left    | boolean          | 0                       |
+| delimiter_align  | string           | 'r'                     |
+| ignore_unmatched | boolean          | 1                       |
+| ignores          | array            | `['String', 'Comment']` |
 
 
 Partial alignment in blockwise-visual mode
@@ -70,16 +134,16 @@ the selected text in the block, instead of the whole lines in the range.
 Ignoring delimiters in comments or strings         *g:easy_align_ignores*
 -------------------------------------------------------------------------
 
-EasyAlign can be configured to ignore delimiters in certain highlight
-groups, such as code comments or strings. By default, delimiters that are
-highlighted as code comments or strings are ignored.
+EasyAlign can be configured to ignore delimiters in certain syntax
+highlight groups, such as code comments or strings. By default, delimiters
+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']
 
-For example,
+For example, the following paragraph
 
     {
       # Quantity of apples: 1
@@ -90,7 +154,7 @@ For example,
       'grape:fruits': 3
     }
 
-becomes
+becomes as follows on `<Enter>:`
 
     {
       # Quantity of apples: 1
@@ -101,10 +165,18 @@ becomes
       'grape:fruits': 3
     }
 
-You can override `g:easy_align_ignores` to change the rule.
+Naturally, this feature only works when syntax highlighting is enabled.
 
+You can change the default rule by either defining global `g:easy_align_ignores`
+array,
+
+    " Ignore nothing!
     let g:easy_align_ignores = []
 
+or providing `ignores` option directly to :EasyAlign command
+
+    :EasyAlign:{'is':[]}
+
 Then you get,
 
     {
@@ -117,10 +189,10 @@ Then you get,
     }
 
 
-Handling unmatched lines                  *g:easy_align_ignore_unmatched*
+Ignoring unmatched lines                  *g:easy_align_ignore_unmatched*
 -------------------------------------------------------------------------
 
-Lines without a matching delimiter are ignored as well (except in
+Lines without any matching delimiter are ignored as well (except in
 right-justification mode).
 
 For example, when aligning the following code block around the colons,
@@ -145,8 +217,16 @@ this is usually what we want.
 
 However, this default behavior is also configurable.
 
+One way is to set the global `g:easy_align_ignore_unmatched` variable to 0.
+
     let g:easy_align_ignore_unmatched = 0
 
+Or in non-interactive mode, you can provide `ignore_unmatched` option to
+`:EasyAlign` command as follows.
+
+    :EasyAlign:{'iu':0}
+
+
 Then we get,
 
     {
@@ -158,23 +238,57 @@ 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
+
 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': '//\+\|/\*\|\*/', 'ignores': ['String'] },
+    \ '#': { 'pattern': '#\+', 'ignores': ['String'] },
     \ ']': {
     \     'pattern':       '[\[\]]',
-    \     'margin_left':   '',
-    \     'margin_right':  '',
+    \     '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
     \   }
     \ }

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>)

test/basic.expected

@@ -0,0 +1,506 @@
+" :source run.vim
+" @a
+
+Pa  ul  Mc  Ca  rt  ne  y{  {1  }}  94 2
+Ge  or  ge  Ha  rr  is  on  {{  1}  }9  43
+Ri  ng  o   St  ar  r   {{  1}  }9  40
+Pe  te  Be  st  {{  1}  }9  41
+
+  Paul McCartney{{1}}942
+George Harrison {{1}}943
+ Ringo Starr    {{1}}940
+  Pete Best     {{1}}941
+
+  Paul McCartney 1942
+George Harrison  1943
+ Ringo Starr     1940
+  Pete Best      1941
+
+Paul  McCartney 1942
+George Harrison 1943
+Ringo     Starr 1940
+Pete       Best 1941
+
+Paul   McCartney 1942
+George Harrison 1943
+Ringo  Starr 1940
+Pete   Best 1941
+
+Paul McCartney  1942
+George Harrison 1943
+Ringo Starr     1940
+Pete Best       1941
+
+Paul   McCartney 1942
+George  Harrison 1943
+Ringo      Starr 1940
+Pete        Best 1941
+
+  Paul McCartney 1942
+George  Harrison 1943
+ Ringo     Starr 1940
+  Pete      Best 1941
+
+Paul  McCartney 1942
+George Harrison 1943
+Ringo     Starr 1940
+Pete       Best 1941
+
+  Paul McCartney 1942
+George Harrison 1943
+ Ringo Starr 1940
+  Pete Best 1941
+
+Paul   McCartney 1942
+George Harrison  1943
+Ringo  Starr     1940
+Pete   Best      1941
+
+Paul McCartney  1942
+George Harrison 1943
+Ringo Starr     1940
+Pete Best       1941
+
+Paul   McCartney 1942
+George Harrison 1943
+Ringo  Starr 1940
+Pete   Best 1941
+
+|     Option | Type    | Default | Description                                    |
+|         -- | --      |      -- | --                                             |
+|    threads | Fixnum  |       1 | number of threads in the thread pool           |
+|     queues | Fixnum  |       1 | number of concurrent queues                    |
+| queue_size | Fixnum  |    1000 | size of each queue                             |
+|   interval | Numeric |       0 | dispatcher interval for batch processing       |
+|      batch | Boolean |   false | enables batch processing mode                  |
+| batch_size | Fixnum  |     nil | number of maximum items to be assigned at once |
+|     logger | Logger  |     nil | logger instance for debug logs                 |
+
+|     Option |    Type | Default |                                    Description |
+|         -- |      -- |      -- |                                             -- |
+|    threads |  Fixnum |       1 |           number of threads in the thread pool |
+|     queues |  Fixnum |       1 |                    number of concurrent queues |
+| queue_size |  Fixnum |    1000 |                             size of each queue |
+|   interval | Numeric |       0 |       dispatcher interval for batch processing |
+|      batch | Boolean |   false |                  enables batch processing mode |
+| batch_size |  Fixnum |     nil | number of maximum items to be assigned at once |
+|     logger |  Logger |     nil |                 logger instance for debug logs |
+
+| Option     | Type    | Default | Description                                    |
+| --         | --      | --      | --                                             |
+| threads    | Fixnum  | 1       | number of threads in the thread pool           |
+| queues     | Fixnum  | 1       | number of concurrent queues                    |
+| queue_size | Fixnum  | 1000    | size of each queue                             |
+| interval   | Numeric | 0       | dispatcher interval for batch processing       |
+| batch      | Boolean | false   | enables batch processing mode                  |
+| batch_size | Fixnum  | nil     | number of maximum items to be assigned at once |
+| logger     | Logger  | nil     | logger instance for debug logs                 |
+
+aaa,   bb,         c
+d,     eeeeeee
+fffff, gggggggggg,
+h,     ,           ii
+j,     ,           k
+
+```ruby
+
+              a   =
+              a   =        1
+           bbbb   =        2
+        ccccccc   =        3
+ccccccccccccccc
+            ddd   =        4
+           eeee ===      eee  = eee = eee=f
+            fff   =      ggg += gg &&= gg
+              g  != hhhhhhhh == 888
+              i  :=        5
+              i  %=        5
+              i  *=        5
+              j  =~        5
+              j  >=        5
+             aa  =>      123
+             aa <<=      123
+             aa >>=      123
+            bbb  =>      123
+              c  =>  1233123
+              d  =>      123
+         dddddd &&=      123
+         dddddd ||=      123
+         dddddd  /=      123
+             gg <=>       ee
+
+a         =
+a         =        1
+bbbb      =        2
+ccccccc   =        3
+ccccccccccccccc
+ddd       =        4
+eeee    ===      eee  = eee   = eee = f
+fff       =      ggg += gg  &&=  gg
+g        != hhhhhhhh == 888
+i        :=        5
+i        %=        5
+i        *=        5
+j        =~        5
+j        >=        5
+aa       =>      123
+aa      <<=      123
+aa      >>=      123
+bbb      =>      123
+c        =>  1233123
+d        =>      123
+dddddd  &&=      123
+dddddd  ||=      123
+dddddd   /=      123
+gg      <=>       ee
+
+a         =
+a         = 1
+bbbb      = 2
+ccccccc   = 3
+ccccccccccccccc
+ddd       = 4
+eeee    === eee       = eee   = eee = f
+fff       = ggg      += gg  &&= gg
+g        != hhhhhhhh == 888
+i        := 5
+i        %= 5
+i        *= 5
+j        =~ 5
+j        >= 5
+aa       => 123
+aa      <<= 123
+aa      >>= 123
+bbb      => 123
+c        => 1233123
+d        => 123
+dddddd  &&= 123
+dddddd  ||= 123
+dddddd   /= 123
+gg      <=> ee
+
+a         =
+a         = 1
+bbbb      = 2
+ccccccc   = 3
+ccccccccccccccc
+ddd       = 4
+eeee    === eee = eee = eee=f
+fff       = ggg += gg &&= gg
+g        != hhhhhhhh == 888
+i        := 5
+i        %= 5
+i        *= 5
+j        =~ 5
+j        >= 5
+aa       => 123
+aa      <<= 123
+aa      >>= 123
+bbb      => 123
+c        => 1233123
+d        => 123
+dddddd  &&= 123
+dddddd  ||= 123
+dddddd   /= 123
+gg      <=> ee
+
+options = {       :caching => nil,
+                 :versions => 3,
+            "cache=blocks" => false }.merge(options)
+
+options = { :caching       => nil,
+            :versions      => 3,
+            "cache=blocks" => false }.merge(options)
+
+options                     = { :caching => nil,
+            :versions      => 3,
+            "cache=blocks" => false }.merge(options)
+
+apple = 1              # comment not aligned
+banana = 'Gros Michel' # comment 2
+
+# let g:easy_align_delimiters = { '#': { 'pattern': '#\+', 'ignores': ['String'] } }
+
+apple = 1              # comment not aligned
+apricot = 'DAD' + 'F#AD'
+banana = 'Gros Michel' # comment 2
+
+apple = 1 # comment not aligned
+apricot = 'DAD' + 'F#AD'
+banana = 'Gros Michel' # comment 2
+
+```
+
+```yaml
+
+        mysql:
+  # JDBC driver for MySQL database:
+       driver: com.mysql.jdbc.Driver
+  # JDBC URL for the connection (jdbc:mysql://HOSTNAME/DATABASE)
+          url: jdbc:mysql://localhost/test
+     database: test
+  "user:pass": r00t:pa55
+
+mysql:
+  # JDBC driver for MySQL database:
+  driver:      com.mysql.jdbc.Driver
+  # JDBC URL for the connection (jdbc:mysql://HOSTNAME/DATABASE)
+  url:         jdbc:mysql://localhost/test
+  database:    test
+  "user:pass": r00t:pa55
+
+```
+```c
+
+/* a */ b          = c
+aa                >= bb
+// aaa             = bbb        = cccc
+/* aaaa            = */ bbbb  === cccc   " = dddd   = " = eeee
+aaaaa /* bbbbb */ == ccccc /*  != eeeee    = */   === fffff
+
+/* a */ b           = c
+aa                 >= bb
+// aaa = bbb = cccc
+/* aaaa = */ bbbb === cccc   " = dddd = "      = eeee
+aaaaa /* bbbbb */  == ccccc /* != eeeee = */ === fffff
+
+```
+
+my_object
+      .method1    .chain
+    .second_method.call
+      .third      .call
+     .method_4    .execute
+
+my_object
+         .method1      .  chain
+         .second_method.   call
+         .third        .   call
+         .method_4     .execute
+
+my_object
+    .      method1.chain
+    .second_method.call
+    .        third.call
+    .     method_4.execute
+
+my_object
+         .      method1.chain
+         .second_method.call
+         .        third.call
+         .     method_4.execute
+
+my_object
+         .      method1.  chain
+         .second_method.   call
+         .        third.   call
+         .     method_4.execute
+
+my_object
+    .method1      .chain
+    .second_method.call
+    .third        .call
+    .method_4     .execute
+
+my_object
+    .method1.chain
+    .second_method.call
+    .third.call
+    .method_4.execute
+
+my_object        .
+      method1    .chain.
+    second_method.call.
+      third      .call.
+     method_4    .execute
+
+  | Option     |    Type | Default |                                    Description |
+  | --         |      -- | --      |                                             -- |
+  | threads    |  Fixnum | 1       |           number of threads in the thread pool |
+  | queues     |  Fixnum | 1       |                    number of concurrent queues |
+  | queue_size |  Fixnum | 1000    |                             size of each queue |
+  | interval   | Numeric | 0       |       dispatcher interval for batch processing |
+  | batch      | Boolean | false   |                  enables batch processing mode |
+  | batch_size |  Fixnum | nil     | number of maximum items to be assigned at once |
+  | logger     |  Logger | nil     |                 logger instance for debug logs |
+
+  |     Option |    Type | Default |                                    Description |
+  |         -- |      -- |      -- |                                             -- |
+  |    threads |  Fixnum |       1 |           number of threads in the thread pool |
+  |     queues |  Fixnum |       1 |                    number of concurrent queues |
+  | queue_size |  Fixnum |    1000 |                             size of each queue |
+  |   interval | Numeric |       0 |       dispatcher interval for batch processing |
+  |      batch | Boolean |   false |                  enables batch processing mode |
+  | batch_size |  Fixnum |     nil | number of maximum items to be assigned at once |
+  |     logger |  Logger |     nil |                 logger instance for debug logs |
+
+  | Option     | Type    | Default | Description                                    |
+  | --         | --      | --      | --                                             |
+  | threads    | Fixnum  | 1       | number of threads in the thread pool           |
+  | queues     | Fixnum  | 1       | number of concurrent queues                    |
+  | queue_size | Fixnum  | 1000    | size of each queue                             |
+  | interval   | Numeric | 0       | dispatcher interval for batch processing       |
+  | batch      | Boolean | false   | enables batch processing mode                  |
+  | batch_size | Fixnum  | nil     | number of maximum items to be assigned at once |
+  | logger     | Logger  | nil     | logger instance for debug logs                 |
+
+
+  |Option         |Type        |Default     |Description                                        |
+  |--             |--          |--          |--                                                 |
+  |threads        |Fixnum      |1           |number of threads in the thread pool               |
+  |queues         |Fixnum      |1           |number of concurrent queues                        |
+  |queue_size     |Fixnum      |1000        |size of each queue                                 |
+  |interval       |Numeric     |0           |dispatcher interval for batch processing           |
+  |batch          |Boolean     |false       |enables batch processing mode                      |
+  |batch_size     |Fixnum      |nil         |number of maximum items to be assigned at once     |
+  |logger         |Logger      |nil         |logger instance for debug logs                     |
+
+  |    Option    <|    Type   <|    Default<|    Description                                   <|
+  |    --        <|    --     <|    --     <|    --                                            <|
+  |    threads   <|    Fixnum <|    1      <|    number of threads in the thread pool          <|
+  |    queues    <|    Fixnum <|    1      <|    number of concurrent queues                   <|
+  |    queue_size<|    Fixnum <|    1000   <|    size of each queue                            <|
+  |    interval  <|    Numeric<|    0      <|    dispatcher interval for batch processing      <|
+  |    batch     <|    Boolean<|    false  <|    enables batch processing mode                 <|
+  |    batch_size<|    Fixnum <|    nil    <|    number of maximum items to be assigned at once<|
+  |    logger    <|    Logger <|    nil    <|    logger instance for debug logs                <|
+
+```c
+
+const char*                          str    = "Hello";
+int64_t                              count  = 1 + 2;
+static double                        pi     = 3.14;
+static std::map<std::string, float>* scores = pointer;
+
+```
+
+  Paul<<< McCartney{{{ 1942
+George<<< Harrison {{{ 1943
+ Ringo<<< Starr    {{{ 1940
+  Pete<<< Best     {{{ 1941
+
+  Paul McCartney 1942
+George  Harrison 1943
+ Ringo     Starr 1940
+  Pete      Best 1941
+
+...    - .     -----
+..    -- ..     ----
+.    --- ...     ---
+    ---- ....     --
+.    --- .....     -
+..    -- ......
+...    - .....     -
+
+...  -   .     -----
+..   --  ..    ----
+.   ---  ...    ---
+    ---- ....   --
+.   ---  .....   -
+..   --  ......
+...  -   .....   -
+
+... -    .     -----
+..  --   ..    ----
+.   ---  ...   ---
+    ---- ....  --
+.   ---  ..... -
+..  --   ......
+... -    ..... -
+
+...  -   .     -----
+..   --  ..    ----
+.   ---  ...    ---
+    ---- ....   --
+.   ---  .....   -
+..   --  ......
+...  -   .....   -
+
+...  -   .-----
+..   --  ..----
+.   ---  ...---
+    ---- ....--
+.   ---  .....-
+..   --  ......
+...  -   .....-
+
+... -    .     -----
+..  --   ..    ----
+.   ---  ...   ---
+    ---- ....  --
+.   ---  ..... -
+..  --   ......
+... -    ..... -
+
+... -    .-----
+..  --   ..----
+.   ---  ...---
+    ---- ....--
+.   ---  .....-
+..  --   ......
+... -    .....-
+
+...    - .-----
+..    -- ..----
+.    --- ...---
+    ---- ....--
+.    --- .....-
+..    -- ......
+...    - .....-
+
+...-.-----
+..--..----
+.---...---
+----....--
+.---.....-
+..--......
+...-.....-
+
+...  -   .     -----
+..   --  ..    ----
+.   ---  ...    ---
+    ---- ....   --
+.   ---  .....   -
+..   --  ......
+...  -   .....   -
+
+...  -   .-----
+..   --  ..----
+.   ---  ...---
+    ---- ....--
+.   ---  .....-
+..   --  ......
+...  -   .....-
+
+... -    .     -----
+..  --   ..    ----
+.   ---  ...   ---
+    ---- ....  --
+.   ---  ..... -
+..  --   ......
+... -    ..... -
+
+...    - .     -----
+..    -- ..     ----
+.    --- ...     ---
+    ---- ....     --
+.    --- .....     -
+..    -- ......
+...    - .....     -
+
+...-.     -----
+..--..     ----
+.---...     ---
+----....     --
+.---.....     -
+..--......
+...-.....     -
+
+...    - .-----
+..    -- ..----
+.    --- ...---
+    ---- ....--
+.    --- .....-
+..    -- ......
+...    - .....-
+

test/basic.md

@@ -0,0 +1,132 @@
+" :source run.vim
+" @a
+
+Paul McCartney 1942
+George Harrison 1943
+Ringo Starr 1940
+Pete Best 1941
+
+| Option| Type | Default | Description |
+|--|--|--|--|
+| threads | Fixnum | 1 | number of threads in the thread pool |
+|queues |Fixnum | 1 | number of concurrent queues |
+|queue_size | Fixnum | 1000 | size of each queue |
+|   interval | Numeric | 0 | dispatcher interval for batch processing |
+|batch | Boolean | false | enables batch processing mode |
+ |batch_size | Fixnum | nil | number of maximum items to be assigned at once |
+ |logger | Logger | nil | logger instance for debug logs |
+
+aaa,   bb,c
+d,eeeeeee
+fffff, gggggggggg,
+h, ,           ii
+j,,k
+
+```ruby
+
+a =
+a = 1
+bbbb = 2
+ccccccc = 3
+ccccccccccccccc
+ddd = 4
+eeee === eee = eee = eee=f
+fff = ggg += gg &&= gg
+g != hhhhhhhh == 888
+i   := 5
+i     %= 5
+i       *= 5
+j     =~ 5
+j   >= 5
+aa      =>         123
+aa <<= 123
+aa        >>= 123
+bbb               => 123
+c     => 1233123
+d   =>      123
+dddddd &&= 123
+dddddd ||= 123
+dddddd /= 123
+gg <=> ee
+
+options = { :caching => nil,
+            :versions => 3,
+            "cache=blocks" => false }.merge(options)
+
+apple = 1 # comment not aligned
+banana = 'Gros Michel' # comment 2
+
+# let g:easy_align_delimiters = { '#': { 'pattern': '#\+', 'ignores': ['String'] } }
+
+apple = 1 # comment not aligned
+apricot = 'DAD' + 'F#AD'
+banana = 'Gros Michel' # comment 2
+
+```
+
+```yaml
+
+mysql:
+  # JDBC driver for MySQL database:
+  driver: com.mysql.jdbc.Driver
+  # JDBC URL for the connection (jdbc:mysql://HOSTNAME/DATABASE)
+  url: jdbc:mysql://localhost/test
+  database: test
+  "user:pass":r00t:pa55
+
+```
+```c
+
+/* a */ b = c
+aa >= bb
+// aaa = bbb = cccc
+/* aaaa = */ bbbb   === cccc   " = dddd = " = eeee
+aaaaa /* bbbbb */      == ccccc /* != eeeee = */ === fffff
+
+```
+
+my_object
+      .method1.chain
+    .second_method.call
+      .third.call
+     .method_4.execute
+
+my_object.
+      method1.chain.
+    second_method.call.
+      third.call.
+     method_4.execute
+
+   | Option| Type | Default | Description |
+    |--|--|--|--|
+       | threads | Fixnum | 1 | number of threads in the thread pool |
+  |queues |Fixnum | 1 | number of concurrent queues |
+   |queue_size | Fixnum | 1000 | size of each queue |
+    |   interval | Numeric | 0 | dispatcher interval for batch processing |
+       |batch | Boolean | false | enables batch processing mode |
+   |batch_size | Fixnum | nil | number of maximum items to be assigned at once |
+   |logger | Logger | nil | logger instance for debug logs |
+
+
+```c
+
+const char* str = "Hello";
+int64_t count = 1 + 2;
+static double pi = 3.14;
+static std::map<std::string, float>* scores =    pointer;
+
+```
+
+Paul McCartney 1942
+George Harrison 1943
+Ringo Starr 1940
+Pete Best 1941
+
+...-.-----
+..--..----
+.---...---
+----....--
+.---.....-
+..--......
+...-.....-
+

test/basic.script

@@ -0,0 +1 @@
+4Gvipjyvip

test/include.vim

@@ -0,0 +1,44 @@
+function! GFM()
+  let syntaxes = {
+  \ 'ruby':   'syntax/ruby.vim',
+  \ 'yaml':   'syntax/yaml.vim',
+  \ 'vim':    'syntax/vim.vim',
+  \ 'sh':     'syntax/sh.vim',
+  \ 'python': 'syntax/python.vim',
+  \ 'java':   'syntax/java.vim',
+  \ 'c':      'syntax/c.vim'
+  \ }
+
+  for [lang, syn] in items(syntaxes)
+    unlet b:current_syntax
+    silent! exec printf("syntax include @%s %s", lang, syn)
+    exec printf("syntax region %sSnip matchgroup=Snip start='```%s' end='```' contains=@%s",
+                \ lang, lang, lang)
+  endfor
+  let b:current_syntax='mkd'
+
+  syntax sync fromstart
+endfunction
+
+silent! unlet g:easy_align_delimiters
+silent! unlet g:easy_align_ignore_unmatched
+silent! unlet g:easy_align_ignores
+
+vnoremap <silent> <Enter> :EasyAlign<cr>
+
+noremap  <silent> <C-k> <nop>
+noremap  <silent> <C-j> <nop>
+noremap  <silent> <C-h> <nop>
+noremap  <silent> <C-l> <nop>
+vnoremap <silent> <C-k> <nop>
+vnoremap <silent> <C-j> <nop>
+vnoremap <silent> <C-h> <nop>
+vnoremap <silent> <C-l> <nop>
+
+set nolazyredraw
+set buftype=nofile
+
+silent! ScrollPositionHide
+
+call GFM()
+

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
+

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
+```
+

test/regexp.script

@@ -0,0 +1 @@
+4Gvipjyvip:EasyAlign:

test/run.vim

@@ -0,0 +1,7 @@
+e!
+execute 'source '. expand('%:p:h') . '/include.vim'
+
+normal gg
+let @b=system('cat '. expand('%:p:r') . '.script')
+let @a='@b:vert diffsplit ' . expand('%:p:r') . '.expected
+'