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.

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

With the mapping, you can align selected lines with a few keystrokes.

<Enter> key to start interactive EasyAlign command
Optional Enter keys to toggle right-justification mode
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)
- -2 Around the second to last occurrences of delimiters
- ...
Delimiter key (a single keystroke; <space>, =, :, ., |, ,)

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
\|	Table markdown

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**=`
...	...

Partial alignment in blockwise-visual mode

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

Consider the following case where you want to align text around => operators.

my_hash = { :a => 1,
            :aa => 2,
            :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 => operators, then press <Enter>=.

my_hash = { :a   => 1,
            :aa  => 2,
            :aaa => 3 }

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

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

Ignoring delimiters in comments or strings

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, the following paragraph

{
  # Quantity of apples: 1
  apple: 1,
  # Quantity of bananas: 2
  bananas: 2,
  # Quantity of grape:fruits: 3
  'grape:fruits': 3
}

becomes as follows on <Enter>:

{
  # Quantity of apples: 1
  apple:          1,
  # Quantity of bananas: 2
  bananas:        2,
  # Quantity of grape:fruits: 3
  'grape:fruits': 3
}

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

You can change the default rule by defining g:easy_align_ignores array.

" Ignore nothing!
let g:easy_align_ignores = []

Then you get,

{
  # Quantity of apples:  1
  apple:                 1,
  # Quantity of bananas: 2
  bananas:               2,
  # Quantity of grape:   fruits: 3
  'grape:                fruits': 3
}

Satisfied? 😆

Ignoring unmatched lines

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,

{
  apple: proc {
    this_line_does_not_have_a_colon
  },
  bananas: 2,
  grapefruits: 3
}

this is usually what we want.

{
  apple:       proc {
    this_line_does_not_have_a_colon
  },
  bananas:     2,
  grapefruits: 3
}

However, this default behavior is also configurable.

let g:easy_align_ignore_unmatched = 0

Then we get,

{
  apple:                             proc {
    this_line_does_not_have_a_colon
  },
  bananas:                           2,
  grapefruits:                       3
}

Extending alignment rules

Although the default predefined rules should cover the most of the use cases, you can extend the rules by setting a dictionary named g:easy_align_delimiters. Each entry in the dictionary can have the following attributes.

Atrribute	Type	Default
pattern	regexp
margin_left	string	`' '`
margin_right	string	`' '`
stick_to_left	boolean	0
ignore_unmatched	boolean	1
ignores	array	['String', 'Comment']

Example

" Examples
let g:easy_align_delimiters = {
\ '>': { 'pattern': '>>\|=>\|>' },
\ '/': { 'pattern': '//\+\|/\*\|\*/', 'ignores': ['String'] },
\ '#': { 'pattern': '#\+', 'ignores': ['String'] },
\ ']': {
\     'pattern':       '[\[\]]',
\     'margin_left':   '',
\     'margin_right':  '',
\     'stick_to_left': 0
\   },
\ ')': {
\     'pattern':       '[()]',
\     'margin_left':   '',
\     'margin_right':  '',
\     'stick_to_left': 0
\   }
\ }

Examples and use cases

See the link for more examples.

Author

Junegunn Choi

License

MIT