" Vimball Archiver by Charles E. Campbell
UseVimball
finish
autoload/repeatableMapping.vim	[[[1
558
" repeatableMapping.vim: Set up mappings that can be repeated via repeat.vim.
"
" DEPENDENCIES:
"   - repeat.vim (vimscript #2136) plugin (optional)
"   - visualrepeat.vim (vimscript #3848) plugin (optional)
"   - ingo-library.vim plugin (optional)
"
" Copyright: (C) 2008-2020 Ingo Karkat
"   The VIM LICENSE applies to this script; see ':help copyright'.
"
" Maintainer:	Ingo Karkat <ingo@karkat.de>
let s:save_cpo = &cpo
set cpo&vim

" Support normal mode repeat of visual mode mapping (through only repeat.vim)
" when visualmode.vim isn't installed.
function! s:VisualMode()
    let l:keys = '1v'
    silent! let l:keys = visualrepeat#reapply#VisualMode(1)
    return l:keys
endfunction
vnoremap <silent> <expr> <SID>(ReapplyRepeatCount) visualrepeat#reapply#RepeatCount()

function! s:ReapplyVisualMode()
    let s:count = v:count
    if visualmode() ==# 'V'
	" If the command to be repeated was in linewise visual mode, the repeat
	" command is invoked for each individual line. Thus, we only need to
	" select the current line.
	return 'V'
    elseif getpos('.') == getpos("'<") || getpos('.') == getpos("'>")
	return 'gv'
    else
	return '1v' . (&selection ==# 'exclusive' ? ' ' : '')
    endif
endfunction
function! s:ReapplyGivenCount()
    return (s:count ? s:count : '')
endfunction
vnoremap <silent> <expr> <SID>(ReapplyGivenCount) <SID>ReapplyGivenCount()
" This gets triggered when repeating visual mode mappings that do not have
" defined a cross-repeatable normal mode mapping. Instead, through something
" like a simple :xmap . or the visualrepeat.vim plugin, the original visual mode
" mapping is re-applied, using this <Plug>(ReenterVisualMode) as a bridge from
" normal-mode back to visual mode.
" Use :normal first to swallow the passed [count], so that it doesn't affect the
" V / gv / 1v commands that are returned by
" s:ReapplyVisualMode(). Then put back the [count] via <SID>(ReapplyGivenCount)
" so that it applies to the repeated mapping. Note that without cross-repeat, a
" normal mode repeat of the visual mode mapping will work, but always on the
" current line / same-size selection with the original [count]. This is
" different from cross-repeat, where one can specify [count] lines / times the
" original selection, with the original repeat.
nnoremap <silent> <script> <Plug>(ReenterVisualMode)
\   :<C-u>execute 'normal! ' . <SID>ReapplyVisualMode()<CR><SID>(ReapplyGivenCount)


let s:register = '"'
function! s:CaptureRegister() abort
    let s:register = v:register
    return ''
endfunction
function! s:GetRegister() abort
    return s:register
endfunction
nnoremap <silent> <expr> <SID>(CaptureRegister) <SID>CaptureRegister()
vnoremap <silent> <expr> <SID>(CaptureRegister) <SID>CaptureRegister()
function! s:ReapplyRegister() abort
    return (s:register ==# '"' ? '' : '"' . s:register)
endfunction
vnoremap <silent> <expr> <SID>(ReapplyRegister) <SID>ReapplyRegister()
function! s:GetCaptureRegisterParameters( isCaptureRegister )
    return (a:isCaptureRegister ?
    \   ['<script> ', '<SID>(CaptureRegister)', 'call <SID>CaptureRegister()<Bar>', '<SID>(ReapplyRegister)'] :
    \   ['', '', '', '']
    \)
endfunction


silent! call ingo#compat#maparg('') " Try loading the ingo-library autoload script before testing for its existence.
function! s:GetRhsAndCmdJoiner( lhs, mapMode )
    if exists('*ingo#compat#maparg')    " Avoid hard dependency to ingo-library.
	let l:rhs = ingo#compat#maparg(a:lhs, a:mapMode)
    else
	let l:rhs = maparg(a:lhs, a:mapMode)
	" Duplicated from ingo#compat#maparg() to avoid dependency to
	" ingo-library.
	let l:rhs = substitute(l:rhs, '\%(\%(^\|[^\\]\)\%(\\\\\)*\\\)\@<!\\\zs<\|<\%([^<]\+>\)\@!', '<lt>', 'g')    " Escape stand-alone < (when not part of a key-notation), or when escaped \<, but not proper key-notation like <C-CR>.
	let l:rhs = substitute(l:rhs, '|', '<Bar>', 'g')    " '|' must be escaped, or the map command will end prematurely.
    endif
    if l:rhs =~? ':.*<CR>'
	let [l:rhsBefore, l:rhsAfter] = matchlist(l:rhs, '^\(.*\)\c<CR>\(.*\)$')[1:2]
	let l:cmdJoiner = '<Bar>'
    else
	let l:rhsBefore = l:rhs
	let l:cmdJoiner = ':'
	let l:rhsAfter = ''
    endif

    return [l:rhsBefore, l:cmdJoiner, l:rhsAfter]
endfunction

function! s:MakePlugMappingWithRepeat( mapCmd, lhs, plugName, ... )
    let l:isCaptureRegister = (a:0 >= 2 && a:2)
    let [l:captureRegisterModifier, l:captureRegisterMapping, l:captureRegisterExpr, l:captureRegisterReapplyMapping] = s:GetCaptureRegisterParameters(l:isCaptureRegister)
    let l:mapMode = (a:mapCmd =~# '^\w\%(nore\)\?map' ? a:mapCmd[0] : '')
    let l:repeatMapping = (l:mapMode =~# '^[vxs]$' ? l:captureRegisterMapping . '\<Plug>(ReenterVisualMode)' . l:captureRegisterReapplyMapping : '') . '\' . a:plugName

    let [l:rhsBefore, l:cmdJoiner, l:rhsAfter] = s:GetRhsAndCmdJoiner(a:lhs, l:mapMode)

    let l:plugMapping = a:mapCmd . ' <silent> ' . l:captureRegisterModifier . a:plugName . ' ' .
    \   l:captureRegisterMapping .
    \   l:rhsBefore .
    \	l:cmdJoiner .
    \   (l:isCaptureRegister ?
    \       'silent! call repeat#setreg("' . l:repeatMapping . '", <SID>GetRegister())<Bar>' :
    \       ''
    \   ) .
    \   'silent! call repeat#set("' .
    \	l:repeatMapping .
    \	'"' . (a:0 && a:1 isnot# '' ? ', ' . s:RenderCount(a:1) : '') .
    \	')<CR>' .
    \   l:rhsAfter
"****D unsilent echomsg l:plugMapping string(a:mapCmd) string(a:lhs) string(a:plugName)
    execute l:plugMapping
endfunction

function! s:PlugMapCmd( mapCmd )
    let l:plugMapCmd = a:mapCmd
    let l:plugMapCmd = substitute(l:plugMapCmd, '\Cnoremap', 'map', '')
    let l:plugMapCmd = substitute(l:plugMapCmd, '\C<script>', '', '')
    return l:plugMapCmd
endfunction
function! s:PlugMap( mapName )
    return (a:mapName =~# '^<Plug>' ? a:mapName : '<Plug>' . a:mapName)
endfunction

function! repeatableMapping#makeRepeatable( mapCmd, lhs, mapName, ... )
"******************************************************************************
"* PURPOSE:
"   Make the mapping of a:lhs repeatable through a new a:mapName <Plug>-mapping.
"* ASSUMPTIONS / PRECONDITIONS:
"   None.
"* EFFECTS / POSTCONDITIONS:
"   Defines new <Plug>-mapping.
"   Modifies the original a:lhs mapping to use the <Plug>-mapping.
"* INPUTS:
"   a:mapCmd	The original mapping command and optional map-arguments used
"		(like "<buffer>"; but <silent> is added implicitly).
"   a:lhs	The mapping's lhs (i.e. keys that invoke the mapping).
"   a:mapName	Name of the intermediate <Plug>-mapping that is created. (The
"		<Plug> prefix is optional.)
"   a:defaultCount  Optional default count for repeat#set(). Pass '' (empty
"                   String) to omit. Can be a Funcref which is then invoked
"                   dynamically (without any arguments) to get the saved
"                   original v:count.
"   a:isRepeatRegister      Optional flag. If 1, the register is also stored and
"                           repeated (via repeat#setreg()).
"* RETURN VALUES:
"   None.
"******************************************************************************
    let l:plugName = s:PlugMap(a:mapName)
    call call('s:MakePlugMappingWithRepeat', [a:mapCmd, a:lhs, l:plugName] + a:000)

    let l:lhsMapping = s:PlugMapCmd(a:mapCmd)  . ' ' . a:lhs . ' ' . l:plugName
"****D unsilent echomsg l:lhsMapping
    execute l:lhsMapping
endfunction

function! repeatableMapping#makePlugMappingRepeatable( mapCmd, mapName, ... )
"******************************************************************************
"* PURPOSE:
"   Make the <Plug>-mapping a:mapName repeatable.
"* ASSUMPTIONS / PRECONDITIONS:
"   None.
"* EFFECTS / POSTCONDITIONS:
"   Redefines the a:mapName <Plug>-mapping.
"* INPUTS:
"   a:mapCmd	The original mapping command and optional map-arguments used
"		(like "<buffer>"; but <silent> is added implicitly).
"   a:mapName	Name of the <Plug>-mapping to be made repeatable.
"   a:defaultCount  Optional default count for repeat#set(). Pass '' (empty
"                   String) to omit. Can be a Funcref which is then invoked
"                   dynamically (without any arguments) to get the saved
"                   original v:count.
"   a:isRepeatRegister      Optional flag. If 1, the register is also stored and
"                           repeated (via repeat#setreg()).
"* RETURN VALUES:
"   None.
"******************************************************************************
    call call('s:MakePlugMappingWithRepeat', [a:mapCmd, a:mapName, a:mapName] + a:000)
endfunction

function! s:RepeatSection( normalRepeatPlug, visualRepeatPlug, ... )
    let l:isCaptureRegister = (a:0 >= 2 && a:2)
    return
    \   (l:isCaptureRegister ?
    \       'silent! call repeat#setreg("' . '\' . a:normalRepeatPlug . '", <SID>GetRegister())<Bar>' :
    \       ''
    \   ) .
    \	'silent! call repeat#set("' .
    \	'\' . a:normalRepeatPlug .
    \	'"' . (a:0 && a:1 isnot# '' ? ', ' . s:RenderCount(a:1) : '') .
    \	')<Bar>silent! call visualrepeat#set("' .
    \	'\' . a:visualRepeatPlug .
    \	'"' . (a:0 && a:1 isnot# '' ? ', ' . s:RenderCount(a:1) : '') .
    \	')<CR>'
endfunction
function! s:RenderCount( Count )
    return (type(a:Count) == type(function('tr')) ?
    \   printf('call(%s, [])', string(a:Count)):
    \   a:Count
    \)
endfunction

function! repeatableMapping#makeCrossRepeatable( normalMapCmd, normalLhs, normalMapName, visualMapCmd, visualLhs, visualMapName, ... )
"******************************************************************************
"* PURPOSE:
"   Make the passed normal and visual mode mappings repeatable, both in the same
"   mode and across the different modes.
"* ASSUMPTIONS / PRECONDITIONS:
"   None.
"* EFFECTS / POSTCONDITIONS:
"   Defines new <Plug>-mappings for normal and visual mode.
"   Modifies the original a:normalLhs and a:visualLhs mappings to use the
"   corresponding <Plug>-mappings.
"* INPUTS:
"   a:normalMapCmd	The original normal mode mapping command and optional
"			map-arguments used (like "<buffer>"; but <silent> is
"			added implicitly).
"   a:normalLhs		The mapping's lhs (i.e. keys that invoke the mapping).
"   a:normalMapName	Name of the intermediate <Plug>-mapping that is created.
"			(The <Plug> prefix is optional.)
"			This must be different from the a:visualMapName;
"			typically the normal mode name contains the scope, e.g.
"			"Line" or "Word".
"   a:visualMapCmd	The original visual mode mapping command and optional
"			map-arguments used (like "<buffer>"; but <silent> is
"			added implicitly).
"			(The <Plug> prefix is optional.)
"   a:visualLhs		The mapping's lhs (i.e. keys that invoke the mapping).
"   a:visualMapName	Name of the intermediate <Plug>-mapping that is created.
"			This must be different from the a:normalMapName;
"			typically the visual mode name contains "Selection".
"   a:defaultCount  Optional default count for repeat#set(). Pass '' (empty
"                   String) to omit. Can be a Funcref which is then invoked
"                   dynamically (without any arguments) to get the saved
"                   original v:count.
"   a:isRepeatRegister      Optional flag. If 1, the register is also stored and
"                           repeated (via repeat#setreg()).
"* RETURN VALUES:
"   None.
"******************************************************************************
    if a:normalMapName ==# a:visualMapName | throw 'ASSERT: normalMapName and visualMapName must be different' | endif

    if ! exists('g:loaded_visualrepeat')
	runtime plugin/visualrepeat.vim
    endif
    if ! exists('g:loaded_visualrepeat') || ! g:loaded_visualrepeat
	" The visualrepeat plugin isn't installed. Fall back to mapping them
	" separately, with just the <Plug>(ReenterVisualMode) feature for the
	" visual mode mapping.
	if ! empty(a:normalMapCmd) | call call('repeatableMapping#makeRepeatable', [a:normalMapCmd, a:normalLhs, a:normalMapName] + a:000) | endif
	if ! empty(a:visualMapCmd) | call call('repeatableMapping#makeRepeatable', [a:visualMapCmd, a:visualLhs, a:visualMapName] + a:000) | endif
	return
    endif

    let l:isCaptureRegister = (a:0 >= 2 && a:2)
    let [l:captureRegisterModifier, l:captureRegisterMapping, l:captureRegisterExpr, l:captureRegisterReapplyMapping] = s:GetCaptureRegisterParameters(l:isCaptureRegister)

    let l:normalPlugName = s:PlugMap(a:normalMapName)
    let l:visualPlugName = s:PlugMap(a:visualMapName)

    let [l:normalRhsBefore, l:normalCmdJoiner, l:normalRhsAfter] = s:GetRhsAndCmdJoiner(a:normalLhs, 'n')
    let [l:visualRhsBefore, l:visualCmdJoiner, l:visualRhsAfter] = s:GetRhsAndCmdJoiner(a:visualLhs, a:visualMapCmd[0])

    let l:normalPlugMapping = a:normalMapCmd . ' <silent> ' . l:captureRegisterModifier . l:normalPlugName . ' ' .
    \   l:captureRegisterMapping .
    \	l:normalRhsBefore .
    \	l:normalCmdJoiner .
    \	call('s:RepeatSection', [l:normalPlugName, l:visualPlugName] + a:000) .
    \   l:normalRhsAfter

    let l:visualPlugMapping = a:visualMapCmd . ' <silent> ' . l:captureRegisterModifier . l:visualPlugName . ' ' .
    \   l:captureRegisterMapping .
    \	l:visualRhsBefore .
    \	l:visualCmdJoiner .
    \	call('s:RepeatSection', [l:visualPlugName, l:visualPlugName] + a:000) .
    \   l:visualRhsAfter

    let l:repeatPlugMapping = a:normalMapCmd . ' <silent> <script> ' . l:visualPlugName . ' ' .
    \	':<C-u>' . l:captureRegisterExpr .  "execute 'normal! ' . <SID>VisualMode()<CR>" .
    \   '<SID>(ReapplyRepeatCount)' .
    \   l:captureRegisterReapplyMapping .
    \	l:visualRhsBefore .
    \	l:visualCmdJoiner .
    \	call('s:RepeatSection', [l:visualPlugName, l:visualPlugName] + a:000) .
    \   l:visualRhsAfter

    if ! empty(a:normalMapCmd)
	execute l:normalPlugMapping
	execute l:repeatPlugMapping
    endif
    if ! empty(a:visualMapCmd)
	execute l:visualPlugMapping
    endif

    let l:normalLhsMapping = s:PlugMapCmd(a:normalMapCmd) . ' ' . a:normalLhs . ' ' . l:normalPlugName
    let l:visualLhsMapping = s:PlugMapCmd(a:visualMapCmd) . ' ' . a:visualLhs . ' ' . l:visualPlugName
    if ! empty(a:normalMapCmd) | execute l:normalLhsMapping | endif
    if ! empty(a:visualMapCmd) | execute l:visualLhsMapping | endif

    return
unsilent echomsg '****' l:normalPlugMapping
unsilent echomsg '****' l:visualPlugMapping
unsilent echomsg '****' l:repeatPlugMapping
unsilent echomsg '****' l:normalLhsMapping
unsilent echomsg '****' l:visualLhsMapping
endfunction
function! repeatableMapping#makePlugMappingWithDifferentRepeatCrossRepeatable( normalMapCmd, normalMapName, normalRepeatMapName, visualMapCmd, visualMapName, visualRepeatMapName, ... )
"******************************************************************************
"* PURPOSE:
"   Make the passed normal and visual mode <Plug>-mappings repeatable via
"   separate repeat <Plug>-mappings, both in the same mode and across the
"   different modes.
"   Use for example when you have a mapping that queries the user, and you want
"   to avoid the query on repeat through a non-interactive mapping variant that
"   recalls the saved original query's value.
"
"* ASSUMPTIONS / PRECONDITIONS:
"   None.
"* EFFECTS / POSTCONDITIONS:
"   Redefines the original a:normalMapName and a:visualMapName mappings.
"* INPUTS:
"   a:normalMapCmd	    The original normal mode mapping command and
"			    optional map-arguments used (like "<buffer>"; but
"			    <silent> is added implicitly).
"   a:normalMapName	    Name of the <Plug>-mapping to be made repeatable.
"			    This must be different from the a:visualMapName;
"			    typically the normal mode name contains the scope,
"			    e.g. "Line" or "Word".
"   a:normalRepeatMapName   Name of the <Plug>-mapping that is invoked on
"			    repeat. Typically like a:normalMapName with appended
"			    "Repeat".
"   a:visualMapCmd	    The original visual mode mapping command and
"			    optional map-arguments used (like "<buffer>"; but
"			    <silent> is added implicitly).
"   a:visualMapName	    Name of the <Plug>-mapping to be made repeatable.
"			    This must be different from the a:normalMapName;
"			    typically the visual mode name contains "Selection".
"   a:visualRepeatMapName   Name of the <Plug>-mapping that is invoked on
"			    repeat. Typically like a:visualMapName with appended
"			    "repeat".
"   a:defaultCount  Optional default count for repeat#set(). Pass '' (empty
"                   String) to omit. Can be a Funcref which is then invoked
"                   dynamically (without any arguments) to get the saved
"                   original v:count.
"   a:isRepeatRegister      Optional flag. If 1, the register is also stored and
"                           repeated (via repeat#setreg()).
"* RETURN VALUES:
"   None.
"******************************************************************************
    if a:normalMapName ==# a:visualMapName | throw 'ASSERT: normalMapName and visualMapName must be different' | endif

    if ! exists('g:loaded_visualrepeat')
	runtime plugin/visualrepeat.vim
    endif
    if ! exists('g:loaded_visualrepeat') || ! g:loaded_visualrepeat
	" The visualrepeat plugin isn't installed. Fall back to mapping them
	" separately, with just the <Plug>(ReenterVisualMode) feature for the
	" visual mode mapping.
	if ! empty(a:normalMapCmd) | call call('repeatableMapping#makePlugMappingRepeatable', [a:normalMapCmd, a:normalRepeatMapName] + a:000) | endif
	if ! empty(a:visualMapCmd) | call call('repeatableMapping#makePlugMappingRepeatable', [a:visualMapCmd, a:visualRepeatMapName] + a:000) | endif
	return
    endif

    let l:isCaptureRegister = (a:0 >= 2 && a:2)
    let [l:captureRegisterModifier, l:captureRegisterMapping, l:captureRegisterExpr, l:captureRegisterReapplyMapping] = s:GetCaptureRegisterParameters(l:isCaptureRegister)

    let [l:normalRhsBefore, l:normalCmdJoiner, l:normalRhsAfter] = s:GetRhsAndCmdJoiner(a:normalMapName, 'n')
    let [l:visualRhsBefore, l:visualCmdJoiner, l:visualRhsAfter] = s:GetRhsAndCmdJoiner(a:visualMapName, a:visualMapCmd[0])

    let l:normalPlugMapping = a:normalMapCmd . ' <silent> ' . l:captureRegisterModifier . a:normalMapName . ' ' .
    \   l:captureRegisterMapping .
    \	l:normalRhsBefore .
    \	l:normalCmdJoiner .
    \	call('s:RepeatSection', [a:normalRepeatMapName, a:visualRepeatMapName] + a:000) .
    \   l:normalRhsAfter

    let l:visualPlugMapping = a:visualMapCmd . ' <silent> ' . l:captureRegisterModifier . a:visualMapName . ' ' .
    \   l:captureRegisterMapping .
    \	l:visualRhsBefore .
    \	l:visualCmdJoiner .
    \	call('s:RepeatSection', [a:visualRepeatMapName, a:visualRepeatMapName] + a:000) .
    \   l:visualRhsAfter

    let l:repeatPlugMapping = a:normalMapCmd . ' <silent> <script> ' . a:visualRepeatMapName . ' ' .
    \	':<C-u>' . l:captureRegisterExpr . "execute 'normal! ' . <SID>VisualMode()<CR>" .
    \   '<SID>(ReapplyRepeatCount)' .
    \   l:captureRegisterReapplyMapping .
    \	l:visualRhsBefore .
    \	l:visualCmdJoiner .
    \	call('s:RepeatSection', [a:visualRepeatMapName, a:visualRepeatMapName] + a:000) .
    \   l:visualRhsAfter

    if ! empty(a:normalMapCmd)
	execute l:normalPlugMapping
	execute l:repeatPlugMapping
    endif
    if ! empty(a:visualMapCmd)
	execute l:visualPlugMapping
    endif

    return
unsilent echomsg '****' l:normalPlugMapping
unsilent echomsg '****' l:visualPlugMapping
unsilent echomsg '****' l:repeatPlugMapping
endfunction
function! repeatableMapping#makePlugMappingCrossRepeatable( normalMapCmd, normalMapName, visualMapCmd, visualMapName, ... )
"******************************************************************************
"* PURPOSE:
"   Make the passed normal and visual mode <Plug>-mappings repeatable, both in
"   the same mode and across the different modes.
"* ASSUMPTIONS / PRECONDITIONS:
"   None.
"* EFFECTS / POSTCONDITIONS:
"   Redefines the original a:normalMapName and a:visualMapName mappings.
"* INPUTS:
"   a:normalMapCmd	The original normal mode mapping command and optional
"			map-arguments used (like "<buffer>"; but <silent> is
"			added implicitly).
"   a:normalMapName	Name of the <Plug>-mapping to be made repeatable.
"			This must be different from the a:visualMapName;
"			typically the normal mode name contains the scope, e.g.
"			"Line" or "Word".
"   a:visualMapCmd	The original visual mode mapping command and optional
"			map-arguments used (like "<buffer>"; but <silent> is
"			added implicitly).
"   a:visualMapName	Name of the <Plug>-mapping to be made repeatable.
"			This must be different from the a:normalMapName;
"			typically the visual mode name contains "Selection".
"   a:defaultCount  Optional default count for repeat#set(). Pass '' (empty
"                   String) to omit. Can be a Funcref which is then invoked
"                   dynamically (without any arguments) to get the saved
"                   original v:count.
"   a:isRepeatRegister      Optional flag. If 1, the register is also stored and
"                           repeated (via repeat#setreg()).
"* RETURN VALUES:
"   None.
"******************************************************************************
    call call('repeatableMapping#makePlugMappingWithDifferentRepeatCrossRepeatable', [a:normalMapCmd, a:normalMapName, a:normalMapName, a:visualMapCmd, a:visualMapName, a:visualMapName] + a:000)
endfunction

function! repeatableMapping#makeMultipleCrossRepeatable( normalDefs, visualMapCmd, visualLhs, visualMapName, ... )
"******************************************************************************
"* PURPOSE:
"   Make the passed list of normal mode mappings and the passed visual mode
"   mapping repeatable, both in the same mode and across the different modes.
"* ASSUMPTIONS / PRECONDITIONS:
"   None.
"* EFFECTS / POSTCONDITIONS:
"   Defines new <Plug>-mappings for normal and visual mode.
"   Modifies the original a:normalLhs and a:visualLhs mappings to use the
"   corresponding <Plug>-mappings.
"* INPUTS:
"   a:normalDefs	List of normal mode mapping definitions, which are
"			tuples of [a:normalMapCmd, a:normalLhs, a:normalMapName]
"	a:normalMapCmd	The original normal mode mapping command and optional
"			map-arguments used (like "<buffer>"; but <silent> is
"			added implicitly).
"	a:normalLhs	The mapping's lhs (i.e. keys that invoke the mapping).
"	a:normalMapName	Name of the intermediate <Plug>-mapping that is created.
"			This must be different from the a:visualMapName;
"			typically the normal mode name contains the scope, e.g.
"			"Line" or "Word".
"			(The <Plug> prefix is optional.)
"   a:visualMapCmd	The original visual mode mapping command and optional
"			map-arguments used (like "<buffer>"; but <silent> is
"			added implicitly).
"   a:visualLhs		The mapping's lhs (i.e. keys that invoke the mapping).
"   a:visualMapName	Name of the intermediate <Plug>-mapping that is created.
"			This must be different from the a:normalMapName;
"			typically the visual mode name contains "Selection".
"			(The <Plug> prefix is optional.)
"   a:defaultCount  Optional default count for repeat#set(). Pass '' (empty
"                   String) to omit. Can be a Funcref which is then invoked
"                   dynamically (without any arguments) to get the saved
"                   original v:count.
"   a:isRepeatRegister      Optional flag. If 1, the register is also stored and
"                           repeated (via repeat#setreg()).
"* RETURN VALUES:
"   None.
"******************************************************************************
    for l:idx in range(len(a:normalDefs))
	" The visual mapping must only be overridden on the last iteration; all
	" repeat mappings must be defined using the original RHS of the visual
	" mapping.
	let l:isLastNormalDef = (l:idx == len(a:normalDefs) - 1)

	call call('repeatableMapping#makeCrossRepeatable',
	\   a:normalDefs[l:idx] +
	\   [(l:isLastNormalDef ? a:visualMapCmd : ''), a:visualLhs, a:visualMapName] +
	\   a:000
	\)
    endfor
endfunction
function! repeatableMapping#makeMultiplePlugMappingCrossRepeatable( normalDefs, visualMapCmd, visualMapName, ... )
"******************************************************************************
"* PURPOSE:
"   Make the passed list of normal mode <Plug>-mappings and the passed visual
"   mode <Plug>-mapping repeatable, both in the same mode and across the
"   different modes.
"* ASSUMPTIONS / PRECONDITIONS:
"   None.
"* EFFECTS / POSTCONDITIONS:
"   Redefines the original <Plug>-mappings for normal and visual mode.
"* INPUTS:
"   a:normalDefs	List of normal mode mapping definitions, which are
"			tuples of [a:normalMapCmd, a:normalMapName]
"	a:normalMapCmd	The original normal mode mapping command and optional
"			map-arguments used (like "<buffer>"; but <silent> is
"			added implicitly).
"	a:normalMapName	Name of the <Plug>-mapping to be made repeatable.
"			This must be different from the a:visualMapName;
"			typically the normal mode name contains the scope, e.g.
"			"Line" or "Word".
"   a:visualMapCmd	The original visual mode mapping command and optional
"			map-arguments used (like "<buffer>"; but <silent> is
"			added implicitly).
"   a:visualMapName	Name of the <Plug>-mapping to be made repeatable.
"			This must be different from the a:normalMapName;
"			typically the visual mode name contains "Selection".
"   a:defaultCount  Optional default count for repeat#set(). Pass '' (empty
"                   String) to omit. Can be a Funcref which is then invoked
"                   dynamically (without any arguments) to get the saved
"                   original v:count.
"   a:isRepeatRegister      Optional flag. If 1, the register is also stored and
"                           repeated (via repeat#setreg()).
"* RETURN VALUES:
"   None.
"******************************************************************************
    for l:idx in range(len(a:normalDefs))
	" The visual mapping must only be overridden on the last iteration; all
	" repeat mappings must be defined using the original RHS of the visual
	" mapping.
	let l:isLastNormalDef = (l:idx == len(a:normalDefs) - 1)

	call call('repeatableMapping#makePlugMappingCrossRepeatable',
	\   a:normalDefs[l:idx] +
	\   [(l:isLastNormalDef ? a:visualMapCmd : ''), a:visualMapName] +
	\   a:000
	\)
    endfor
endfunction

let &cpo = s:save_cpo
unlet s:save_cpo
" vim: set ts=8 sts=4 sw=4 noexpandtab ff=unix fdm=syntax :
doc/repeatableMapping.txt	[[[1
291
*repeatableMapping.txt* Set up mappings that can be repeated via repeat.vim.

		     REPEATABLE MAPPING    by Ingo Karkat
						       *repeatableMapping.vim*
description			|repeatableMapping-description|
usage				|repeatableMapping-usage|
installation			|repeatableMapping-installation|
limitations			|repeatableMapping-limitations|
known problems			|repeatableMapping-known-problems|
todo				|repeatableMapping-todo|
history				|repeatableMapping-history|

==============================================================================
DESCRIPTION				       *repeatableMapping-description*

This plugin simplifies the application of the repeat.vim and visualrepeat.vim
repeat functionality to existing mappings. As with repeat.vim, all
embellishments are optional; if the corresponding plugin isn't available, the
call will be ignored and the original mappings persist unchanged (though
without any repeat functionality).

RETROFIT MAPPING REPETITION						    *
Some plugins provide out-of-the-box support for repeat.vim, many do not.
Some mappings have been developed in an ad-hoc fashion, e.g. as custom
filetype-specific workflow shortcuts, and therefore do not have the
canonical remapping layer of <Plug> mappings (which repeat.vim requires).

This plugin allows to retrofit repeatability to mappings from plugins that
do not directly use repeat.vim. It also offers a succinct way for custom
mappings to acquire repeatability, and spares them the definition of
<Plug>-mappings and adding the repeat#set() boilerplate code themselves.


VISUAL MODE REPETITION							    *
repeat.vim only supports normal mode repetition, as this is the only
repetition that is built into Vim. However, one can define repetition in
visual mode: >
    xnoremap . :normal .<CR>
or with pass-through of [count]: >
    xnoremap . :execute 'normal' (v:count ? v:count : '') . '.'<CR>
(Or better a more fancy version that only applies the repeat command over
entire lines in linewise visual mode, keeps the current cursor position in
characterwise visual mode, and does nothing (sensible) in blockwise visual
mode. The |visualrepeat.vim| plugin provides this.)

The <Plug>(ReenterVisualMode) mapping allows to apply repeat.vim repetition to
visual mode commands; just prepend it in the call to repeat#set(): >
    vnoremap <silent> <Plug>MyMapping ...:silent! call repeat#set("\<Plug>(ReenterVisualMode)\<Plug>MyMapping")<CR>

If a previously used visual mode mapping is repeated from an active visual
selection, that selection is the affected area for the repetition. The
recorded repeat count is passed to the mapping.

If repetition is invoked in normal mode, the repetition works on a new
selection, depending on the last visual mode:
- For linewise selections, the repetition selects the current line.
- For characterwise selections, a new selection starting at the cursor
  position, with the same size as the last visual selection is used. |1v|
A [count] is passed to the mapping and overrides the recorded one.

If a non-visual mode mapping is repeated from an active visual selection, it
won't (can't) apply to the visual selection, but to whatever that mapping
typically applies. So, you can only repeat previous visual mode mappings on
a visual selection! The only way around this is to cross-link both mapping
types, and to use a more intelligent version of the repeat definition in
visual mode. This is described next:

CROSS-REPEAT								     *
Through the |visualrepeat.vim| plugin, it is possible to make normal mode and
visual mode mappings repeat each other, with the normal mode mapping repeated
over the visual selection, and the visual mode mapping repeated over a new
selection, such as:
- For previous linewise selections, the repetition applies to the same amount
  of lines, unless a different [count] is given. In that case, it selects
  [count] lines starting at the cursor position.
- Else, a new selection starting at the cursor position, with the same size as
  the last visual selection (times [count], if given and different) is used.
  |1v|
The mapping itself is always repeated with the recorded [count], not a new
given one. For cross-repeat of a visual mode mapping in normal mode, a new
different [count] only affects the range it applies to!

For cross-repeat, use the |repeatableMapping#makeCrossRepeatable()| function,
for single normal mode and visual mode mappings, and
|repeatableMapping#makeMultipleCrossRepeatable()| for multiple normal mode and
a single visual mode mapping.
For existing <Plug>-mappings, there's the
|repeatableMapping#makeMultiplePlugMappingCrossRepeatable()| function.

If the repeat needs to go to a different <Plug>-mapping (for example when you
have a mapping that queries the user, and you want to avoid the query on
repeat through a non-interactive mapping variant that recalls the saved
original query's value), use the
|repeatableMapping#makePlugMappingWithDifferentRepeatCrossRepeatable()|
function. With this variant of |repeatableMapping#makeCrossRepeatable()|, you
can specify separate repeat <Plug>-mappings: >
    silent! call repeatableMapping#makePlugMappingWithDifferentRepeatCrossRepeatable(
    \   'nnoremap', '<Plug>(FooRange)',           '<Plug>(FooRangeRepeat)',
    \   'xnoremap', '<Plug>(FooSelection)',       '<Plug>(FooSelectionRepeat)'
    \)
    silent! call repeatableMapping#makePlugMappingWithDifferentRepeatCrossRepeatable(
    \   'nnoremap', '<Plug>(FooRangeRepeat)',     '<Plug>(FooRangeRepeat)',
    \   'xnoremap', '<Plug>(FooSelectionRepeat)', '<Plug>(FooSelectionRepeat)'
    \)
<
==============================================================================
USAGE						     *repeatableMapping-usage*

RETROFIT MAPPING REPETITION						    *
First define your mapping in the usual way: >
    nnoremap <silent> <Leader>v :version<CR>
Then make the mapping repeatable; this will redefine the original mapping
and insert the call to repeat#set() at the end. >
    silent! call repeatableMapping#makeRepeatable('nnoremap', '<Leader>v', 'ShowVersion')
>
The processing requires the following information:
- The original mapping command (for the map-mode, whether |:noremap| or not,
  any optional map-arguments like "<buffer>"; "<silent>" is added
  automatically to avoid showing the repeat invocation).
- The mapping's {lhs} (i.e. keys that invoke the mapping).
- A unique name for the intermediate <Plug>-mapping that needs to be created
  so that repeat.vim can invoke it.
- Optional: The default count that will be prefixed to the mapping if no
  explicit numeric argument was given; i.e. the second optional argument of
  repeat#set(). If your mapping doesn't accept a numeric argument and you
  never want to receive one, pass a value of -1.
Note that the wrapped Ex command in the mapping must support command
sequencing with | (i.e. custom commands must be defined with |:command-bar|),
as the repeat insertion will be appended with <Bar>. If that is not the case,
wrap the command in |:execute|.

If you already have a <Plug> mapping: >
    vnoremap <silent> <Plug>ShowVersion :<C-U>version<CR>
    vmap <Leader>v <Plug>ShowVersion
You can redefine the <Plug> mapping directly, and just have the call to
repeat#set() appended: >
    silent! call repeatableMapping#makePlugMappingRepeatable('vnoremap', '<Plug>ShowVersion')
This is especially useful to retrofit existing visual mode mappings with the
ability to be repeatable, in conjunction with the visual mode repetition
described above.

VISUAL MODE REPETITION							    *
First define your normal and visual mode mappings: >
    nnoremap <buffer> <LocalLeader>qq :s/^/> /<CR>
    vnoremap <buffer> <LocalLeader>q  :s/^/> /<CR>
<
You could now make both mappings repeatable via two separate calls to
|repeatableMapping#makeRepeatable()|, as described in the above section, but
with that, the mappings won't repeat each other. Therefore, it is recommended
to use |repeatableMapping#makeCrossRepeatable()|, so that the normal mode
mapping can be repeated over a visual selection and vice versa: >
    silent! call repeatableMapping#makeCrossRepeatable(
    \   'nnoremap <buffer>', '<LocalLeader>qq', 'QuoteLine',
    \   'vnoremap <buffer>', '<LocalLeader>q',  'QuoteSelection'
    \)
<
Again, if you already have <Plug> mappings (and need them for a configurable
plugin), you can use the alternative function: >
    silent! call repeatableMapping#makePlugMappingCrossRepeatable(
    \   'nnoremap <buffer>', '<Plug>QuoteLine',
    \   'vnoremap <buffer>', '<Plug>QuoteSelection'
    \)
Note that you need to do this _after_ any >
    if ! hasmapto('<Plug>QuoteLine', 'n') ...
default mapping tests; because the <Plug>-mapping is contained in the
retrofitted mapping, the test would otherwise always be false, and the default
mappings would be missing!

==============================================================================
INSTALLATION				      *repeatableMapping-installation*

The code is hosted in a Git repo at
    https://github.com/inkarkat/vim-repeatableMapping
You can use your favorite plugin manager, or "git clone" into a directory used
for Vim |packages|. Releases are on the "stable" branch, the latest unstable
development snapshot on "master".

This script is also packaged as a |vimball|. If you have the "gunzip"
decompressor in your PATH, simply edit the *.vmb.gz package in Vim; otherwise,
decompress the archive first, e.g. using WinZip. Inside Vim, install by
sourcing the vimball or via the |:UseVimball| command. >
    vim repeatableMapping*.vmb.gz
    :so %
To uninstall, use the |:RmVimball| command.

DEPENDENCIES				      *repeatableMapping-dependencies*

- Requires Vim 7.0 or higher.
- repeat.vim (vimscript #2136) plugin (optional, but without it this plugin
  doesn't provide any functionality).
- visualrepeat.vim (vimscript #3848 plugin) (version 2.00 or higher; optional,
  but recommended for cross-repeat functionality).

==============================================================================
LIMITATIONS				       *repeatableMapping-limitations*

- When your mapping uses |:normal| commands or a sequence of Ex commands
  separated by <CR>:, the original [count] is lost and won't be used in
  repeats. If you need the count, you cannot use this plugin. Instead,
  preserve the count yourself at the beginning of the mapping, and implement
  the calls to |repeat#set()| yourself.

KNOWN PROBLEMS				    *repeatableMapping-known-problems*

TODO						      *repeatableMapping-todo*

IDEAS						     *repeatableMapping-ideas*

CONTRIBUTING					*repeatableMapping-contribute*

Report any bugs, send patches, or suggest features via the issue tracker at
https://github.com/inkarkat/vim-repeatableMapping/issues or email (address
below).

==============================================================================
HISTORY						   *repeatableMapping-history*

2.20	03-Apr-2020
- ENH: All functions now support a second optional a:isRepeatRegister argument
  (to skip specifying a a:defaultCount, pass an empty String as the first
  optional argument) that if set invokes repeat#setreg() before the original
  {rhs} and also tweaks the repeat mappings that recreate a visual selection
  (which clobber count and also register) to save and restore the repeated
  register for the repeat as well.

2.11	25-Jul-2019
- Documentation: Mention that a <silent> map-argument does not need to be
  passed; I was confused about this myself.
- FIX: The ingo-library may not be loaded yet (as repeatable mappings are
  usually defined early in plugin scripts); try loading it before testing for
  its existence.
- Escaping (duplicated from ingo#compat#maparg()) didn't consider <; in fact,
  it needs to escape stand-alone < and escaped \<, but not proper key
  notations like <C-CR>.

2.10	08-Mar-2015
- ENH: Allow to pass Funcref as a:defaultCount; the value will then be
  determined via a dynamic lookup. This is necessary for mappings that clobber
  v:count (e.g. due to use of :normal). They can now save the original count
  and pass it on to the repeat part via the Funcref, which is more elegant
  than a global variable.

2.01	19-Nov-2014
- BUG: Typo in repeatableMapping#makePlugMappingCrossRepeatable() causes
  "E116: Invalid arguments for function call", which unfortunately usually is
  suppressed by the :silent! invocation.

2.00	22-Nov-2013
- ENH: Enable cross-repeat for existing <Plug>-mappings (as provided by
  plugins), too. The new functions parallel to the existing ones are
  repeatableMapping#makePlugMappingCrossRepeatable(),
  repeatableMapping#makeMultipleCrossRepeatable().
- CHG: In cross-repeat, select [count] lines / times the original selection
  when [count] is given and different from the repeat count, and pass the
  original count into the repeated mapping.
- Rework <Plug>(ReenterVisualMode) for when there's no cross-repeat to handle
  [count] in a way similar to the changed cross-repeat.
- FIX: Optional a:defaultCount argument for repeat#set() is only used when
  visualrepeat.vim is not installed.
- FIX: Also need to drop off <script> from the a:mapCmd to turn it into an
  effective <Plug> mapping command.
- ENH: Insert the repeat calls after the last <CR>, even if it is not at the
  end of the original mapping. This allows preserving the count for those
  mappings, too.
- Minor: Consider actual visual map mode of a:visualMapCmd (one of 'v', 'x',
  or 's').
- Move the functions for cross-repeating a visual mapping in normal mode
  through visualrepeat.vim to visualrepeat/reapply.vim to allow re-use in
  other plugins without forcing a dependency to this plugin. Since this
  functionality is only ever invoked through an installed visualrepeat.vim, it
  truly belongs there, not here.
- Make the <Plug> prefix optional for repeatableMapping#makeRepeatable(),
  repeatableMapping#makeCrossRepeatable(),
  repeatableMapping#makeMultipleCrossRepeatable().
- ENH: Also allow cross-repeat for existing <Plug>-mappings that need to call
  a different repeat <Plug>-mapping via
  repeatableMapping#makePlugMappingWithDifferentRepeatCrossRepeatable().

1.00	13-Dec-2011 (unreleased)
First version.

0.01	24-Sep-2008
Started development.

==============================================================================
Copyright: (C) 2008-2020 Ingo Karkat
The VIM LICENSE applies to this plugin; see |copyright|.

Maintainer:	Ingo Karkat <ingo@karkat.de>
==============================================================================
 vim:tw=78:ts=8:ft=help:norl: