m-vim_plugins/vim-easy-align
1
0
Fork 0
mirror of https://github.com/junegunn/vim-easy-align.git synced 2025-11-17 06:13:41 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Implement live interactive mode (#15)

Browse Source 
This commit adds LiveEasyAlign command. (The name was chosen not to introduce
ambiguity when typing in only the prefix of the command: e.g. `:EasyA*|`)
In live interactive mode, the selected text is aligned on-the-fly as the user
type in. In order to finalize the alignment, the user has to type in the
same delimiter key again. (Or CTRL-X on regular expressions)
This commit is contained in:
Junegunn Choi
2013-10-19 19:21:23 +09:00
parent bec3e94383
commit 6e2264672a
6 changed files with 318 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

349
autoload/easy_align.vim
View File

@@ -326,13 +326,13 @@ function! s:split_line(line, nth, modes, cycle, fc, lc, pattern, stick_to_left,
return [tokens, delims]
endfunction
function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, pattern, nth,
\ ml, mr, da, indentation, stick_to_left, ignore_unmatched, ignore_groups, recur)
function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, recur, dict)
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 }
let d = a:dict
" Phase 1
for line in range(a:fl, a:ll)
@@ -340,8 +340,8 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, patter
" Split line into the tokens by the delimiters
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)
\ a:fc, a:lc, d.pattern,
\ d.stick_to_left, d.ignore_unmatched, d.ignore_groups)
" Remember tokens for subsequent recursive calls
let a:all_tokens[line] = tokens
@@ -383,7 +383,7 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, patter
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
if empty(delim) && !exists('tokens[nth + 1]') && d.ignore_unmatched
continue
endif
@@ -409,17 +409,18 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, patter
" Phase 1-5: indentation handling (only on a:nth == 1)
if a:nth == 1
if a:indentation ==? 'd'
let idt = d.indentation
if idt ==? 'd'
let indent = repeat(' ', max.indent)
elseif a:indentation ==? 's'
elseif idt ==? 's'
let indent = repeat(' ', min_indent)
elseif a:indentation ==? 'n'
elseif idt ==? 'n'
let indent = ''
elseif a:indentation !=? 'k'
call s:exit('Invalid indentation: ' . a:indentation)
elseif idt !=? 'k'
call s:exit('Invalid indentation: ' . idt)
end
if a:indentation !=? 'k'
if idt !=? 'k'
let max.just_len = 0
let max.token_len = 0
let max.pivot_len = 0
@@ -461,7 +462,7 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, patter
let rpad = ''
if mode ==? 'l'
let pad = repeat(' ', max.just_len - pw - tw)
if a:stick_to_left
if d.stick_to_left
let rpad = pad
else
let token = token . pad
@@ -480,7 +481,7 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, patter
let token = repeat(' ', float2nr(pf1)) .token. repeat(' ', float2nr(p2))
let token = substitute(token, repeat(' ', strip) . '$', '', '')
if a:stick_to_left
if d.stick_to_left
if empty(s:rtrim(token))
let center = len(token) / 2
let [token, rpad] = [strpart(token, 0, center), strpart(token, center)]
@@ -493,15 +494,16 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, patter
" Pad the delimiter
let dpadl = max.delim_len - s:strwidth(delim)
if a:da ==? 'l'
let da = d.delimiter_align
if da ==? 'l'
let [dl, dr] = ['', repeat(' ', dpadl)]
elseif a:da ==? 'c'
elseif da ==? 'c'
let dl = repeat(' ', dpadl / 2)
let dr = repeat(' ', dpadl - dpadl / 2)
elseif a:da ==? 'r'
elseif da ==? 'r'
let [dl, dr] = [repeat(' ', dpadl), '']
else
call s:exit('Invalid delimiter_align: ' . a:da)
call s:exit('Invalid delimiter_align: ' . da)
endif
" Before and after the range (for blockwise visual mode)
@@ -511,8 +513,8 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, patter
" Determine the left and right margin around the delimiter
let rest = join(tokens[nth + 1 : -1], '')
let ml = empty(prefix . token) ? '' : a:ml
let mr = empty(rest.after) ? '' : a:mr
let ml = empty(prefix . token) ? '' : d.ml
let mr = empty(rest.after) ? '' : d.mr
" Adjust indentation of the lines starting with a delimiter
let lpad = ''
@@ -535,12 +537,8 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, patter
if a:nth < max.tokens && (a:recur || len(a:modes) > 1)
call s:shift(a:modes, a:recur == 2)
return [
\ a:todo,
\ 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]
return [a:todo, a:modes, a:all_tokens, a:all_delims,
\ a:fl, a:ll, a:fc, a:lc, a:nth + 1, a:recur, a:dict]
endif
return [a:todo]
endfunction
@@ -571,26 +569,56 @@ function! s:shift_opts(opts, key, vals)
endif
endfunction
function! s:interactive(modes, vis, opts, delims)
function! s:interactive(range, modes, n, d, opts, rules, vis, live)
let mode = s:shift(a:modes, 1)
let n = ''
let n = a:n
let d = a:d
let ch = ''
let opts = s:compact_options(a:opts)
let vals = deepcopy(s:option_values)
let regx = 0
let warn = ''
let undo = 0
while 1
call s:echon(mode, n, -1, '', opts, warn)
" Live preview
let rdrw = 0
if undo
silent! undo
let undo = 0
let rdrw = 1
endif
if a:live && !empty(d)
let output = s:process(a:range, mode, n, d, s:normalize_options(opts), regx, a:rules, 0)
let &undolevels = &undolevels " Break undo block
call s:update_lines(output.todo)
let undo = 1
let rdrw = 1
endif
if rdrw
if a:vis
normal! gv
endif
redraw
if a:vis | execute "normal! \<esc>" | endif
endif
call s:echon(mode, n, -1, regx ? '/'.d.'/' : d, opts, warn)
let check = 0
let warn = ''
let c = getchar()
let ch = nr2char(c)
if c == 3 || c == 27 " CTRL-C / ESC
if undo
silent! undo
endif
throw 'exit'
elseif c == "\<bs>"
if len(n) > 0
if !empty(d)
let d = ''
let regx = 0
elseif len(n) > 0
let n = strpart(n, 0, len(n) - 1)
endif
elseif c == 13 " Enter key
@@ -609,7 +637,7 @@ function! s:interactive(modes, vis, opts, delims)
elseif n == '**' | let n = ''
else | let check = 1
endif
elseif (c == 48 && len(n) > 0) || c > 48 && c <= 57 " Numbers
elseif empty(d) && ((c == 48 && len(n) > 0) || c > 48 && c <= 57) " Numbers
if n[0] == '*' | let check = 1
else | let n = n . ch
end
@@ -661,11 +689,16 @@ function! s:interactive(modes, vis, opts, delims)
silent! call remove(opts, 'm')
endif
elseif ch == "\<C-_>" || ch == "\<C-X>"
if a:live && regx && !empty(d)
break
endif
let prompt = 'Regular expression: '
let ch = s:input(prompt, '', a:vis)
if !empty(ch) && s:valid_regexp(ch)
let regx = 1
break
let d = ch
if !a:live | break | endif
else
let warn = 'Invalid regular expression: '.ch
endif
@@ -676,14 +709,33 @@ function! s:interactive(modes, vis, opts, delims)
endif
if check
if has_key(a:delims, ch)
break
if empty(d)
if has_key(a:rules, ch)
let d = ch
if !a:live
break
endif
else
let warn = 'Unknown delimiter key: '.ch
endif
else
let warn = 'Unknown delimiter key: '.ch
if regx
let warn = 'Press <CTRL-X> to finish'
else
if d == ch
break
else
let warn = 'Press '''.d.''' again to finish'
endif
end
endif
endif
endwhile
return [mode, n, ch, s:normalize_options(opts), regx]
if a:live
let copts = call('s:summarize', output.summarize)
let g:easy_align_last_command = s:echon('', n, regx, d, copts, '')
end
return [mode, n, ch, opts, regx]
endfunction
function! s:valid_regexp(regexp)
@@ -751,6 +803,9 @@ function! s:parse_shorthand_opts(expr)
endfunction
function! s:parse_args(args)
if empty(a:args)
return ['', '', {}, 0]
endif
let n = ''
let ch = ''
let args = a:args
@@ -804,55 +859,42 @@ function! s:parse_args(args)
return [matches[1], s:test_regexp(matches[2]), opts, 1]
else
let tokens = matchlist(args, '^\([1-9][0-9]*\|-[0-9]*\|\*\*\?\)\?\s*\(.\{-}\)\?$')
return [tokens[1], tokens[2], opts, 0]
" Try swapping n and ch
let [n, ch] = empty(tokens[2]) ? reverse(tokens[1:2]) : tokens[1:2]
" Resolving command-line ambiguity
" '\ ' => ' '
" '\' => ' '
if ch =~ '^\\\s*$'
let ch = ' '
" '\\' => '\'
elseif ch =~ '^\\\\\s*$'
let ch = '\'
endif
return [n, ch, opts, 0]
endif
endfunction
function! s:modes(bang)
function! s:interactive_modes(bang)
return get(g:,
\ (a:bang ? 'easy_align_bang_interactive_modes' : 'easy_align_interactive_modes'),
\ (a:bang ? ['r', 'l', 'c'] : ['l', 'r', 'c']))
endfunction
function! s:alternating_modes(mode)
return a:mode ==? 'r' ? ['r', 'l'] : ['l', 'r']
return a:mode ==? 'r' ? 'rl' : 'lr'
endfunction
function! easy_align#align(bang, expr) range
try
call s:align(a:bang, a:firstline, a:lastline, a:expr)
catch 'exit'
endtry
function! s:update_lines(todo)
for [line, content] in items(a:todo)
call setline(line, s:rtrim(content))
endfor
endfunction
function! s:align(bang, first_line, last_line, expr)
let modes = s:modes(a:bang)
let mode = modes[0]
let recur = 0
let n = ''
let ch = ''
let opts = {}
let regexp = 0
" Heuristically determine if the user was in visual mode
let vis = a:first_line == line("'<") && a:last_line == line("'>")
let delimiters = s:easy_align_delimiters_default
if exists('g:easy_align_delimiters')
let delimiters = extend(copy(delimiters), g:easy_align_delimiters)
endif
if empty(a:expr)
let [mode, n, ch, opts, regexp] = s:interactive(copy(modes), vis, opts, delimiters)
else
let [n, ch, opts, regexp] = s:parse_args(a:expr)
if empty(n) && empty(ch)
let [mode, n, ch, opts, regexp] = s:interactive(copy(modes), vis, opts, delimiters)
elseif empty(ch)
" Try swapping n and ch
let [n, ch] = ['', n]
endif
endif
function! s:parse_nth(n)
let n = a:n
let recur = 0
if n == '*' | let [nth, recur] = [1, 1]
elseif n == '**' | let [nth, recur] = [1, 2]
elseif n == '-' | let nth = -1
@@ -862,93 +904,134 @@ function! s:align(bang, first_line, last_line, expr)
else
let nth = n
endif
return [nth, recur]
endfunction
if regexp
let dict = { 'pattern': ch }
function! s:build_dict(delimiters, ch, regexp, opts)
if a:regexp
let dict = { 'pattern': a:ch }
else
" Resolving command-line ambiguity
if !empty(a:expr)
" '\ ' => ' '
" '\' => ' '
if ch =~ '^\\\s*$'
let ch = ' '
" '\\' => '\'
elseif ch =~ '^\\\\\s*$'
let ch = '\'
endif
if !has_key(a:delimiters, a:ch)
call s:exit('Unknown delimiter key: '. a:ch)
endif
if !has_key(delimiters, ch)
call s:exit('Unknown delimiter key: '. ch)
endif
let dict = copy(delimiters[ch])
let dict = copy(a:delimiters[a:ch])
endif
call extend(dict, opts)
call extend(dict, a:opts)
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
call extend(dict, { 'ml': ml, 'mr': mr })
let bvisual = vis && char2nr(visualmode()) == 22 " ^V
let dict.pattern = get(dict, 'pattern', a:ch)
let dict.delimiter_align =
\ get(dict, 'delimiter_align', get(g:, 'easy_align_delimiter_align', 'r'))[0]
let dict.indentation =
\ get(dict, 'indentation', get(g:, 'easy_align_indentation', 'k'))[0]
let dict.stick_to_left =
\ get(dict, 'stick_to_left', 0)
let dict.ignore_unmatched =
\ get(dict, 'ignore_unmatched', get(g:, 'easy_align_ignore_unmatched', 2))
let dict.ignore_groups =
\ get(dict, 'ignore_groups', get(dict, 'ignores', s:ignored_syntax()))
return dict
endfunction
if recur && bvisual
function! s:build_mode_sequence(expr, recur)
let [expr, recur] = [a:expr, a:recur]
let suffix = matchstr(a:expr, '\*\+$')
if suffix == '*'
let expr = expr[0 : -2]
let recur = 1
elseif suffix == '**'
let expr = expr[0 : -3]
let recur = 2
endif
return [tolower(expr), recur]
endfunction
function! s:process(range, mode, n, ch, opts, regexp, rules, bvis)
let [nth, recur] = s:parse_nth(a:n)
let dict = s:build_dict(a:rules, a:ch, a:regexp, a:opts)
let [mode_sequence, recur] = s:build_mode_sequence(
\ get(dict, 'mode_sequence', recur == 2 ? s:alternating_modes(a:mode) : a:mode),
\ recur)
if recur && a:bvis
call s:exit('Recursive alignment is not supported in blockwise-visual mode')
endif
let aseq = get(dict, 'mode_sequence',
\ recur == 2 ? s:alternating_modes(mode) : [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)')
let aseq_str = join(aseq_list, '')
let todo = {}
let args = [
\ todo,
\ aseq_list,
\ {}, {}, a:first_line, a:last_line,
\ 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', 2)),
\ get(dict, 'ignore_groups', get(dict, 'ignores', s:ignored_syntax())),
\ recur ]
\ {}, split(mode_sequence, '\zs'),
\ {}, {}, a:range[0], a:range[1],
\ a:bvis ? min([col("'<"), col("'>")]) : 1,
\ a:bvis ? max([col("'<"), col("'>")]) : 0,
\ nth, recur, dict ]
while len(args) > 1
let args = call('s:do_align', args)
endwhile
" todo: lines to update
" summarize: arguments to s:summarize
return { 'todo': args[0], 'summarize': [ a:opts, recur, mode_sequence ] }
endfunction
function s:summarize(opts, recur, mode_sequence)
let copts = s:compact_options(a:opts)
let nbmode = s:interactive_modes(0)[0]
if !has_key(copts, 'm') && (
\ (a:recur == 2 && s:alternating_modes(nbmode) != a:mode_sequence) ||
\ (a:recur != 2 && (a:mode_sequence[0] != nbmode || len(a:mode_sequence) > 1))
\ )
call extend(copts, { 'm': a:mode_sequence })
endif
return copts
endfunction
function! s:align(bang, live, first_line, last_line, expr)
" Heuristically determine if the user was in visual mode
let vis = a:first_line == line("'<") && a:last_line == line("'>")
let bvis = vis && char2nr(visualmode()) == 22 " ^V
let range = [a:first_line, a:last_line]
let modes = s:interactive_modes(a:bang)
let mode = modes[0]
if bvis && a:live
call s:exit('Live mode is not supported in blockwise-visual mode')
endif
let rules = s:easy_align_delimiters_default
if exists('g:easy_align_delimiters')
let rules = extend(copy(rules), g:easy_align_delimiters)
endif
let [n, ch, opts, regexp] = s:parse_args(a:expr)
let bypass_fold = get(g:, 'easy_align_bypass_fold', 0)
let ofm = &l:foldmethod
try
if bypass_fold | let &l:foldmethod = 'manual' | endif
for [line, content] in items(todo)
call setline(line, s:rtrim(content))
endfor
if empty(n) && empty(ch) || a:live
let [mode, n, ch, opts, regexp] = s:interactive(range, copy(modes), n, ch, opts, rules, vis, a:live)
endif
if !a:live
let output = s:process(range, mode, n, ch, s:normalize_options(opts), regexp, rules, bvis)
call s:update_lines(output.todo)
let copts = call('s:summarize', output.summarize)
let g:easy_align_last_command = s:echon('', n, regexp, ch, copts, '')
endif
finally
if bypass_fold | let &l:foldmethod = ofm | endif
endtry
let copts = s:compact_options(opts)
let nbmode = s:modes(0)[0]
if !has_key(copts, 'm') && (
\ (recur == 2 && join(s:alternating_modes(nbmode), '') != aseq_str) ||
\ (recur != 2 && (aseq_str[0] != nbmode || len(aseq_str) > 1))
\ )
call extend(copts, { 'm': aseq_str })
endif
let g:easy_align_last_command = s:echon('', n, regexp, ch, copts, '')
endfunction
function! easy_align#align(bang, live, expr) range
try
call s:align(a:bang, a:live, a:firstline, a:lastline, a:expr)
catch 'exit'
endtry
endfunction