path: root/autoload/paste_insert.vim

" Autoloaded entry point function
function! paste_insert#() abort

  " Set up an event table
  augroup paste_insert
    autocmd!

    " Set up the paste and tell the user
    autocmd User Start
          \ call s:Start() | echo 'Paste ready'

    " When starting insert mode, add completion hook for when we leave
    autocmd InsertEnter *
          \ autocmd paste_insert InsertLeave *
                \ doautocmd paste_insert User Complete

    " User waits too long in normal mode, timeout
    autocmd CursorHold *
          \ doautocmd paste_insert User Timeout

    " User leaves the buffer or window, abort
    autocmd BufLeave,WinLeave *
          \ doautocmd paste_insert User Abort

    " Exit condition reporting
    autocmd User Abort
          \ echo 'Paste aborted'
    autocmd User Cancel
          \ echo 'Paste cancelled'
    autocmd User Complete
          \ echo 'Paste completed'
    autocmd User Timeout
          \ echo 'Paste timeout'

    " End the paste and clear the events table
    autocmd User Abort,Cancel,Complete,Timeout
          \ call s:Stop() | autocmd! paste_insert

  augroup END

  " Trigger the starting actions
  doautocmd paste_insert User Start

endfunction

" Keys that cancel the pending paste in normal mode, defaults to Ctrl-C and
" Escape
let s:cancel = get(g:, 'paste_insert_cancel', ['<C-C>', '<Esc>'])

" Cache for the prior functions of those keys, in case the user has already
" mapped them
let s:maps = {}

function! s:MapArg(key, mode) abort
  if v:version > 703 || v:version == 703 && has('patch-32')
    return maparg(a:key, a:mode, 0, 1)
  else
    let rhs = maparg(a:key, a:mode)
    if rhs ==# ''
      return {}
    else
      return { 'rhs': rhs }
    endif
  endif
endfunction

" Start the paste: save each cancel key's prior function, remap it, set
" 'paste'
function! s:Start() abort
  for key in s:cancel
    let maps = []
    try
      let map = s:MapArg(key, 'n')
      if !empty(map)
        call add(maps, s:MapArg(key, 'n'))
      endif
      execute 'nunmap <buffer> '.key
      let map = s:MapArg(key, 'n')
      if !empty(map)
        call add(maps, s:MapArg(key, 'n'))
      endif
      execute 'nunmap '.key
    catch
    endtry
    if len(maps) == 2
      let maps[0]['buffer'] = 1
    endif
    let s:maps[key] = maps
    execute 'nnoremap '.key
          \.' :<C-U>doautocmd paste_insert User Cancel<CR>'
  endfor
  set paste
endfunction

" Stop the paste: unset 'paste', restore prior function of cancel key
function! s:Stop() abort
  set nopaste
  for key in s:cancel
    execute 'nunmap '.key
    for map in reverse(s:maps[key])
      let command = !has_key(map, 'noremap') || map['noremap']
              \ ? ['nnoremap']
              \ : ['nmap']
      for flag in ['buffer', 'expr', 'nowait', 'silent']
        if has_key(map, flag) && map[flag]
          call add(command, '<'.flag.'>')
        endif
      endfor
      call extend(command, [key, map['rhs']])
      execute join(command)
    endfor
    unlet s:maps[key]
  endfor
endfunction