dotfiles/homedir/.vim/plugin/AutoClose.vim
fbt c78cb78ff0 init
Signed-off-by: fbt <fbt@fleshless.org>
2017-05-03 16:10:13 +03:00

543 lines
18 KiB
VimL
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

scriptencoding utf-8
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" AutoClose.vim - Automatically close pair of characters: ( with ), [ with ], { with }, etc.
" Version: 2.0
" Author: Thiago Alves <talk@thiagoalves.com.br>
" Maintainer: Thiago Alves <talk@thiagoalves.com.br>
" URL: http://thiagoalves.com.br
" Licence: This script is released under the Vim License.
" Last modified: 02/02/2011
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" check if script is already loaded
if !exists("g:debug_AutoClose") && exists("g:loaded_AutoClose")
finish "stop loading the script"
endif
let g:loaded_AutoClose = 1
let s:global_cpo = &cpo " store compatible-mode in local variable
set cpo&vim " go into nocompatible-mode
if !exists('g:AutoClosePreserveDotReg')
let g:AutoClosePreserveDotReg = 1
endif
if g:AutoClosePreserveDotReg
" Because dot register preservation code remaps escape we have to remap
" some terminal specific escape sequences first
if &term =~ 'xterm' || &term =~ 'rxvt' || &term =~ 'screen' || &term =~ 'linux' || &term =~ 'gnome'
imap <silent> <Esc>OA <Up>
imap <silent> <Esc>OB <Down>
imap <silent> <Esc>OC <Right>
imap <silent> <Esc>OD <Left>
imap <silent> <Esc>OH <Home>
imap <silent> <Esc>OF <End>
imap <silent> <Esc>[5~ <PageUp>
imap <silent> <Esc>[6~ <PageDown>
endif
endif
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" Functions
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
function! s:GetCharAhead(len)
if col('$') == col('.')
return "\0"
endif
return strpart(getline('.'), col('.')-2 + a:len, 1)
endfunction
function! s:GetCharBehind(len)
if col('.') == 1
return "\0"
endif
return strpart(getline('.'), col('.') - (1 + a:len), 1)
endfunction
function! s:GetNextChar()
return s:GetCharAhead(1)
endfunction
function! s:GetPrevChar()
return s:GetCharBehind(1)
endfunction
" used to implement automatic deletion of closing character when opening
" counterpart is deleted and by space expansion
function! s:IsEmptyPair()
let l:prev = s:GetPrevChar()
let l:next = s:GetNextChar()
return (l:next != "\0") && (get(b:AutoClosePairs, l:prev, "\0") == l:next)
endfunction
function! s:GetCurrentSyntaxRegion()
return synIDattr(synIDtrans(synID(line('.'), col('.'), 1)), 'name')
endfunction
function! s:GetCurrentSyntaxRegionIf(char)
let l:origin_line = getline('.')
let l:changed_line = strpart(l:origin_line, 0, col('.')-1) . a:char . strpart(l:origin_line, col('.')-1)
call setline('.', l:changed_line)
let l:region = synIDattr(synIDtrans(synID(line('.'), col('.'), 1)), 'name')
call setline('.', l:origin_line)
return l:region
endfunction
function! s:IsForbidden(char)
let l:result = index(b:AutoCloseProtectedRegions, s:GetCurrentSyntaxRegion()) >= 0
if l:result
return l:result
endif
let l:region = s:GetCurrentSyntaxRegionIf(a:char)
let l:result = index(b:AutoCloseProtectedRegions, l:region) >= 0
return l:result || l:region == 'Comment'
endfunction
function! s:AllowQuote(char, isBS)
let l:result = 1
if b:AutoCloseSmartQuote
let l:initPos = 1 + (a:isBS ? 1 : 0)
let l:charBehind = s:GetCharBehind(l:initPos)
let l:prev = l:charBehind
let l:backSlashCount = 0
while l:charBehind == '\'
let l:backSlashCount = l:backSlashCount + 1
let l:charBehind = s:GetCharBehind(l:initPos + l:backSlashCount)
endwhile
if l:backSlashCount % 2
let l:result = 0
else
if a:char == "'" && l:prev =~ '[a-zA-Z0-9]'
let l:result = 0
endif
endif
endif
return l:result
endfunction
function! s:CountQuotes(char)
let l:currPos = col('.')-1
let l:line = strpart(getline('.'), 0, l:currPos)
let l:result = 0
if l:currPos >= 0
for [q,closer] in items(b:AutoClosePairs)
" only consider twin pairs
if q != closer | continue | endif
if b:AutoCloseSmartQuote != 0
let l:regex = q . '[ˆ\\' . q . ']*(\\.[ˆ\\' . q . ']*)*' . q
else
let l:regex = q . '[ˆ' . q . ']*' . q
endif
let l:closedQuoteIdx = match(l:line, l:regex)
while l:closedQuoteIdx >= 0
let l:matchedStr = matchstr(l:line, l:regex, l:closedQuoteIdx)
let l:line = strpart(l:line, 0, l:closedQuoteIdx) . strpart(l:line, l:closedQuoteIdx + strlen(l:matchedStr))
let l:closedQuoteIdx = match(l:line, l:regex)
endwhile
endfor
for c in split(l:line, '\zs')
if c == a:char
let l:result = l:result + 1
endif
endfor
endif
return l:result
endfunction
" The auto-close buffer is used in a fix of the redo functionality.
" As we insert characters after cursor, we remember them and at the moment
" that vim would normally collect the last entered string into dot register
" (:help ".) - i.e. when esc or a motion key is typed in insert mode - we
" erase the inserted symbols and pretend that we have just now typed them.
" This way vim picks them up into dot register as well and user can repeat the
" typed bit with . command.
function! s:PushBuffer(char)
if !exists("b:AutoCloseBuffer")
let b:AutoCloseBuffer = []
endif
call insert(b:AutoCloseBuffer, a:char)
endfunction
function! s:PopBuffer()
if exists("b:AutoCloseBuffer") && len(b:AutoCloseBuffer) > 0
call remove(b:AutoCloseBuffer, 0)
endif
endfunction
function! s:EmptyBuffer()
if exists("b:AutoCloseBuffer")
let b:AutoCloseBuffer = []
endif
endfunction
function! s:FlushBuffer()
let l:result = ''
if exists("b:AutoCloseBuffer")
let l:len = len(b:AutoCloseBuffer)
if l:len > 0
let l:result = join(b:AutoCloseBuffer, '') . repeat("\<Left>", l:len)
let b:AutoCloseBuffer = []
call s:EraseNCharsAtCursor(l:len)
endif
endif
return l:result
endfunction
function! s:InsertStringAtCursor(str)
let l:line = getline('.')
let l:column = col('.')-2
if l:column < 0
call setline('.', a:str . l:line)
else
call setline('.', l:line[:l:column] . a:str . l:line[l:column+1:])
endif
endfunction
function! s:EraseNCharsAtCursor(len)
let l:line = getline('.')
let l:column = col('.')-2
if l:column < 0
call setline('.', l:line[a:len + 1:])
else
call setline('.', l:line[:l:column] . l:line[l:column + a:len + 1:])
endif
endfunction
" returns the opener, after having inserted its closer if necessary
function! s:InsertPair(opener)
if ! b:AutoCloseOn || ! has_key(b:AutoClosePairs, a:opener) || s:IsForbidden(a:opener)
return a:opener
endif
let l:save_ve = &ve
set ve=all
let l:next = s:GetNextChar()
" only add closing pair before space or any of the closepair chars
let close_before = '\s\|\V\[,.;' . escape(join(keys(b:AutoClosePairs) + values(b:AutoClosePairs), ''), ']').']'
if (l:next == "\0" || l:next =~ close_before) && s:AllowQuote(a:opener, 0)
call s:InsertStringAtCursor(b:AutoClosePairs[a:opener])
call s:PushBuffer(b:AutoClosePairs[a:opener])
endif
exec "set ve=" . l:save_ve
return a:opener
endfunction
" returns the closer, after having eaten identical one if necessary
function! s:ClosePair(closer)
let l:save_ve = &ve
set ve=all
if b:AutoCloseOn && s:GetNextChar() == a:closer
call s:EraseNCharsAtCursor(1)
call s:PopBuffer()
endif
exec "set ve=" . l:save_ve
return a:closer
endfunction
" in case closer is identical with its opener - heuristically decide which one
" is being typed and act accordingly
function! s:OpenOrCloseTwinPair(char)
if s:CountQuotes(a:char) % 2 == 0
" act as opening char
return s:InsertPair(a:char)
else
" act as closing char
return s:ClosePair(a:char)
endif
endfunction
" maintain auto-close buffer when delete key is pressed
function! s:Delete()
let l:save_ve = &ve
set ve=all
if exists("b:AutoCloseBuffer") && len(b:AutoCloseBuffer) > 0 && b:AutoCloseBuffer[0] == s:GetNextChar()
call s:PopBuffer()
endif
exec "set ve=" . l:save_ve
return "\<Del>"
endfunction
" when backspace is pressed:
" - erase an empty pair if backspacing from inside one
" - maintain auto-close buffer
function! s:Backspace()
let l:save_ve = &ve
let l:prev = s:GetPrevChar()
let l:next = s:GetNextChar()
set ve=all
if b:AutoCloseOn && s:IsEmptyPair() && (l:prev != l:next || s:AllowQuote(l:prev, 1))
call s:EraseNCharsAtCursor(1)
call s:PopBuffer()
endif
exec "set ve=" . l:save_ve
return "\<BS>"
endfunction
function! s:Space()
if b:AutoCloseOn && s:IsEmptyPair()
call s:PushBuffer("\<Space>")
return "\<Space>\<Space>\<Left>"
else
return "\<Space>"
endif
endfunction
function! s:Enter()
if has_key(b:AutoClosePumvisible, 'ENTER') && pumvisible()
let b:snippet_chosen = 1
return b:AutoClosePumvisible['ENTER']
elseif b:AutoCloseOn && s:IsEmptyPair() && stridx( b:AutoCloseExpandEnterOn, s:GetPrevChar() ) >= 0
return "\<CR>\<Esc>O"
endif
return "\<CR>"
endfunction
function! s:ToggleAutoClose()
let b:AutoCloseOn = !b:AutoCloseOn
if b:AutoCloseOn
echo "AutoClose ON"
else
echo "AutoClose OFF"
endif
endfunction
" Parse a whitespace separated line of pairs
" single characters are assumed to be twin pairs (closer identical to
" opener)
function! AutoClose#ParsePairs(string)
if type(a:string) == type({})
return a:string
elseif type(a:string) != type("")
echoerr "AutoClose#ParsePairs(): Argument not a dictionary or a string"
return {}
endif
let l:dict = {}
for pair in split(a:string)
" strlen is length in bytes, we want in (wide) characters
let l:pairLen = strlen(substitute(pair,'.','x','g'))
if l:pairLen == 1
" assume a twin pair
let l:dict[pair] = pair
elseif l:pairLen == 2
let l:dict[pair[0]] = pair[1]
else
echoerr "AutoClose: Bad pair string - a pair longer then two character"
echoerr " `- String: " . a:sring
echoerr " `- Pair: " . pair . " Pair len: " . l:pairLen
endif
endfor
return l:dict
endfunction
" this function is made visible for the sake of users
function! AutoClose#DefaultPairs()
return AutoClose#ParsePairs(g:AutoClosePairs)
endfunction
function! s:ModifyPairsList(list, pairsToAdd, openersToRemove)
return filter(
\ extend(a:list, AutoClose#ParsePairs(a:pairsToAdd), "force"),
\ "stridx(a:openersToRemove,v:key)<0")
endfunction
function! AutoClose#DefaultPairsModified(pairsToAdd,openersToRemove)
return s:ModifyPairsList(AutoClose#DefaultPairs(), a:pairsToAdd, a:openersToRemove)
endfunction
" Define variables (in the buffer namespace).
function! s:DefineVariables()
" All the following variables can be set per buffer or global.
" The buffer namespace is used internally
let defaults = {
\ 'AutoClosePairs': AutoClose#DefaultPairs(),
\ 'AutoCloseProtectedRegions': ["Comment", "String", "Character"],
\ 'AutoCloseSmartQuote': 1,
\ 'AutoCloseOn': 1,
\ 'AutoCloseSelectionWrapPrefix': '<LEADER>a',
\ 'AutoClosePumvisible': {"ENTER": "\<C-Y>", "ESC": "\<C-E>"},
\ 'AutoCloseExpandEnterOn': "",
\ 'AutoCloseExpandSpace': 1,
\ }
" Let the user define if he/she wants the plugin to do special actions when the
" popup menu is visible and a movement key is pressed.
" Movement keys used in the menu get mapped to themselves
" (Up/Down/PageUp/PageDown).
for key in s:movementKeys
if key == 'ENTER' || key == 'ESC'
continue
endif
let defaults['AutoClosePumvisible'][key] = ''
endfor
for key in s:pumMovementKeys
if key == 'ENTER' || key == 'ESC'
continue
endif
let defaults['AutoClosePumvisible'][key] = '<'.key.'>'
endfor
if exists ('b:AutoClosePairs') && type('b:AutoClosePairs') == type("")
let tmp = AutoClose#ParsePairs(b:AutoClosePairs)
unlet b:AutoClosePairs
let b:AutoClosePairs = tmp
endif
" Now handle/assign values
for key in keys(defaults)
if key == 'AutoClosePumvisible'
let tempVisible = defaults['AutoClosePumvisible']
if exists('g:AutoClosePumvisible') && type(eval('g:AutoClosePumvisible')) == type(defaults['AutoClosePumvisible'])
for childKey in keys(g:AutoClosePumvisible)
let tempVisible[toupper(childKey)] = g:AutoClosePumvisible[childKey]
endfor
endif
if exists('b:AutoClosePumvisible') && type(eval('b:AutoClosePumvisible')) == type(defaults['AutoClosePumvisible'])
for childKey in keys(b:AutoClosePumvisible)
let tempVisible[toupper(childKey)] = b:AutoClosePumvisible[childKey]
endfor
endif
let b:AutoClosePumvisible = tempVisible
else
if exists('b:'.key) && type(eval('b:'.key)) == type(defaults[key])
continue
elseif exists('g:'.key) && type(eval('g:'.key)) == type(defaults[key])
exec 'let b:' . key . ' = g:' . key
else
exec 'let b:' . key . ' = ' . string(defaults[key])
endif
endif
endfor
endfunction
function! s:CreatePairsMaps()
" create appropriate maps to defined open/close characters
for key in keys(b:AutoClosePairs)
let opener = s:keyName(key)
let closer = s:keyName(b:AutoClosePairs[key])
let quoted_opener = s:quoteAndEscape(opener)
let quoted_closer = s:quoteAndEscape(closer)
exec "xnoremap <buffer> <silent> ". b:AutoCloseSelectionWrapPrefix
\ . opener . " <Esc>`>a" . closer . "<Esc>`<i" . opener . "<Esc>"
exec "xnoremap <buffer> <silent> ". b:AutoCloseSelectionWrapPrefix
\ . closer . " <Esc>`>a" . closer . "<Esc>`<i" . opener . "<Esc>"
if key == b:AutoClosePairs[key]
exec "inoremap <buffer> <silent> " . opener
\ . " <C-R>=<SID>OpenOrCloseTwinPair(" . quoted_opener . ")<CR>"
else
exec "inoremap <buffer> <silent> " . opener
\ . " <C-R>=<SID>InsertPair(" . quoted_opener . ")<CR>"
exec "inoremap <buffer> <silent> " . closer
\ . " <C-R>=<SID>ClosePair(" . quoted_closer . ")<CR>"
endif
endfor
endfunction
function! s:CreateExtraMaps()
" Extra mapping
inoremap <buffer> <silent> <BS> <C-R>=<SID>Backspace()<CR>
inoremap <buffer> <silent> <Del> <C-R>=<SID>Delete()<CR>
if b:AutoCloseExpandSpace
inoremap <buffer> <silent> <Space> <C-R>=<SID>Space()<CR>
endif
if len(b:AutoCloseExpandEnterOn) > 0
inoremap <buffer> <silent> <CR> <C-R>=<SID>Enter()<CR>
endif
if g:AutoClosePreserveDotReg
" Fix the re-do feature by flushing the char buffer on key movements (including Escape):
for key in s:movementKeys
let l:pvisiblemap = b:AutoClosePumvisible[key]
let key = "<".key.">"
let l:currentmap = maparg(key,"i")
if (l:currentmap=="")|let l:currentmap=key|endif
if len(l:pvisiblemap)
exec "inoremap <buffer> <silent> <expr> " . key . " pumvisible() ? '" . l:pvisiblemap . "' : '<C-R>=<SID>FlushBuffer()<CR>" . l:currentmap . "'"
else
exec "inoremap <buffer> <silent> " . key . " <C-R>=<SID>FlushBuffer()<CR>" . l:currentmap
endif
endfor
" Flush the char buffer on mouse click:
inoremap <buffer> <silent> <LeftMouse> <C-R>=<SID>FlushBuffer()<CR><LeftMouse>
inoremap <buffer> <silent> <RightMouse> <C-R>=<SID>FlushBuffer()<CR><RightMouse>
endif
endfunction
function! s:CreateMaps()
silent doautocmd FileType
call s:DefineVariables()
call s:CreatePairsMaps()
call s:CreateExtraMaps()
let b:loaded_AutoClose = 1
endfunction
function! s:IsLoadedOnBuffer()
return (exists("b:loaded_AutoClose") && b:loaded_AutoClose)
endfunction
" map some characters to their key names
function! s:keyName(char)
let s:keyNames = {'|': '<Bar>', ' ': '<Space>'}
return get(s:keyNames,a:char,a:char)
endfunction
" escape some characters for use in strings
function! s:quoteAndEscape(char)
let s:escapedChars = {'"': '\"'}
return '"' . get(s:escapedChars,a:char,a:char) . '"'
endfunction
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" Configuration
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
let s:AutoClosePairs_FactoryDefaults = AutoClose#ParsePairs("() {} [] ` \" '")
if !exists("g:AutoClosePairs_add") | let g:AutoClosePairs_add = "" | endif
if !exists("g:AutoClosePairs_del") | let g:AutoClosePairs_del = "" | endif
if !exists("g:AutoClosePairs")
let g:AutoClosePairs = s:ModifyPairsList(
\ s:AutoClosePairs_FactoryDefaults,
\ g:AutoClosePairs_add,
\ g:AutoClosePairs_del )
endif
let s:movementKeys = split('ESC UP DOWN LEFT RIGHT HOME END PAGEUP PAGEDOWN')
" list of keys that get mapped to themselves for pumvisible()
let s:pumMovementKeys = split('UP DOWN PAGEUP PAGEDOWN')
if has("gui_macvim")
call extend(s:movementKeys, split("D-LEFT D-RIGHT D-UP D-DOWN M-LEFT M-RIGHT M-UP M-DOWN"))
endif
augroup <Plug>(autoclose)
autocmd!
autocmd BufNewFile,BufRead,BufEnter * if !<SID>IsLoadedOnBuffer() | call <SID>CreateMaps() | endif
autocmd InsertEnter * call <SID>EmptyBuffer()
autocmd BufEnter * if mode() == 'i' | call <SID>EmptyBuffer() | endif
augroup END
" Define convenient commands
command! AutoCloseOn :let b:AutoCloseOn = 1
command! AutoCloseOff :let b:AutoCloseOn = 0
command! AutoCloseToggle :call s:ToggleAutoClose()
" vim:sw=4:sts=4: