vim/tpope.vim-surround
1
0
Fork 0
mirror of https://github.com/tpope/vim-surround.git synced 2026-09-11 07:46:24 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: vim:master
Branches Tags
vim:master
vim:v2.2
vim:v2.1
vim:v2.0
vim:v1.90
..
compare: vim:v1.90
Branches Tags
vim:master
vim:v2.2
vim:v2.1
vim:v2.0
vim:v1.90

No commits in common. "master" and "v1.90" have entirely different histories.
master ... v1.90

5 changed files with 191 additions and 280 deletions
Show stats Expand all files Collapse all files

2
.github/FUNDING.yml vendored
View file

@ -1,2 +0,0 @@
github: tpope
custom: ["https://www.paypal.me/vimpope"]

1
.gitignore vendored
View file

@ -1 +0,0 @@
/doc/tags

98
README.markdown
View file

@ -1,98 +0,0 @@
# surround.vim
Surround.vim is all about "surroundings": parentheses, brackets, quotes,
XML tags, and more. The plugin provides mappings to easily delete,
change and add such surroundings in pairs.
It's easiest to explain with examples. Press `cs"'` inside
"Hello world!"
to change it to
'Hello world!'
Now press `cs'<q>` to change it to
<q>Hello world!</q>
To go full circle, press `cst"` to get
"Hello world!"
To remove the delimiters entirely, press `ds"`.
Hello world!
Now with the cursor on "Hello", press `ysiw]` (`iw` is a text object).
[Hello] world!
Let's make that braces and add some space (use `}` instead of `{` for no
space): `cs]{`
{ Hello } world!
Now wrap the entire line in parentheses with `yssb` or `yss)`.
({ Hello } world!)
Revert to the original text: `ds{ds)`
Hello world!
Emphasize hello: `ysiw<em>`
<em>Hello</em> world!
Finally, let's try out visual mode. Press a capital V (for linewise
visual mode) followed by `S<p class="important">`.
<p class="important">
<em>Hello</em> world!
</p>
This plugin is very powerful for HTML and XML editing, a niche which
currently seems underfilled in Vim land. (As opposed to HTML/XML
*inserting*, for which many plugins are available). Adding, changing,
and removing pairs of tags simultaneously is a breeze.
The `.` command will work with `ds`, `cs`, and `yss` if you install
[repeat.vim](https://github.com/tpope/vim-repeat).
## Installation
Install using your favorite package manager, or use Vim's built-in package
support:
mkdir -p ~/.vim/pack/tpope/start
cd ~/.vim/pack/tpope/start
git clone https://tpope.io/vim/surround.git
vim -u NONE -c "helptags surround/doc" -c q
## FAQ
> How do I surround without adding a space?
Only the opening brackets—`[`, `{`, and `(`—add a space. Use a closing
bracket, or the `b` (`(`) and `B` (`{`) aliases.
## Contributing
See the contribution guidelines for
[pathogen.vim](https://github.com/tpope/vim-pathogen#readme).
## Self-Promotion
Like surround.vim? Star the repository on
[GitHub](https://github.com/tpope/vim-surround) and vote for it on
[vim.org](https://www.vim.org/scripts/script.php?script_id=1697).
Love surround.vim? Follow [tpope](http://tpo.pe/) on
[GitHub](https://github.com/tpope) and
[Twitter](http://twitter.com/tpope).
## License
Copyright (c) Tim Pope. Distributed under the same terms as Vim itself.
See `:help license`.

79
doc/surround.txt
View file

@ -1,6 +1,6 @@
*surround.txt* Plugin for deleting, changing, and adding "surroundings"
Author: Tim Pope <http://tpo.pe/>
Author: Tim Pope <vimNOSPAM@tpope.info> *surround-author*
License: Same terms as Vim itself (see |license|)
This plugin is only available if 'compatible' is not set.
@ -20,7 +20,7 @@ examples. An asterisk (*) is used to denote the cursor position.
[123+4*56]/2 cs]) (123+456)/2
"Look ma, I'm *HTML!" cs"<q> <q>Look ma, I'm HTML!</q>
if *x>3 { ysW( if ( x>3 ) {
my $str = *whee!; vllllS' my $str = 'whee!';
my $str = *whee!; vlllls' my $str = 'whee!';
While a few features of this plugin will work in older versions of Vim,
Vim 7 is recommended for full functionality.
@ -39,9 +39,8 @@ easiest to understand with some examples:
<div>Yo!*</div> dst Yo!
Change surroundings is *cs* . It takes two arguments, a target like with
|ds|, and a replacement. *cS* changes surroundings, placing the surrounded
text on its own line(s) like |yS|. Details about the second argument can be
found below in |surround-replacements|. Once again, examples are in order.
|ds|, and a replacement. Details about the second argument can be found
below in |surround-replacements|. Once again, examples are in order.
Old text Command New text ~
"Hello *world!" cs"' 'Hello world!'
@ -51,8 +50,8 @@ found below in |surround-replacements|. Once again, examples are in order.
<div>Yo!*</div> cst<p> <p>Yo!</p>
*ys* takes a valid Vim motion or text object as the first object, and wraps
it using the second argument as with |cs|. (It's a stretch, but a good
mnemonic for "ys" is "you surround".)
it using the second argument as with |cs|. (Unfortunately there's no good
mnemonic for "ys".)
Old text Command New text ~
Hello w*orld! ysiw) Hello (world)!
@ -66,19 +65,28 @@ whitespace.
There is also *yS* and *ySS* which indent the surrounded text and place it
on a line of its own.
In visual mode, a simple "S" with an argument wraps the selection. This is
In visual mode, a simple "s" with an argument wraps the selection. This is
referred to as the *vS* mapping, although ordinarily there will be
additional keystrokes between the v and S. In linewise visual mode, the
additional keystrokes between the v and s. In linewise visual mode, the
surroundings are placed on separate lines and indented. In blockwise visual
mode, each line is surrounded.
A "gS" in visual mode, known as *vgS* , behaves similarly. In linewise visual
mode, the automatic indenting is suppressed. In blockwise visual mode, this
enables surrounding past the end of the line with 'virtualedit' set (there
mode, the automatic indenting is surpressed. In blockwise visual mode, this
enables surrounding past the end of the like with 'virtualedit' set (there
seems to be no way in Vim Script to differentiate between a jagged end of line
selection and a virtual block selected past the end of the line, so two maps
were needed).
Additionally, there is a legacy "s" or *vs* mapping which is basically the
same as |vS|. Due to popular demand of wanting to use "s" as Vim does to mean
replacing the selection (also available as "c"), this mapping is going away.
If you were one of these people and would like to disable "s" with the current
release, indicate this to surround.vim by assigning the "s" mapping to
something else.
>
xmap <Leader>s <Plug>Vsurround
<
*i_CTRL-G_s* *i_CTRL-G_S*
Finally, there is an experimental insert mode mapping on <C-G>s and <C-S>.
Beware that the latter won't work on terminals with flow control (if you
@ -92,11 +100,13 @@ TARGETS *surround-targets*
The |ds| and |cs| commands both take a target as their first argument. The
possible targets are based closely on the |text-objects| provided by Vim.
All targets are currently just one character.
In order for a target to work, the corresponding text object must be
supported in the version of Vim used (Vim 7 adds several text objects, and
thus is highly recommended). All targets are currently just one character.
Eight punctuation marks, (, ), {, }, [, ], <, and >, represent themselves
and their counterparts. If the opening mark is used, contained whitespace is
also trimmed. The targets b, B, r, and a are aliases for ), }, ], and >
also trimmed. The targets b, B, r, and a are aliases for ), }, ], and >
(the first two mirror Vim; the second two are completely arbitrary and
subject to change).
@ -118,7 +128,7 @@ however, newlines are sometimes added and/or removed.
REPLACEMENTS *surround-replacements*
A replacement argument is a single character, and is required by |cs|, |ys|,
and |vS|. Undefined replacement characters (with the exception of alphabetic
and |vs|. Undefined replacement characters (with the exception of alphabetic
characters) default to placing themselves at the beginning and end of the
destination, which can be useful for characters like / and |.
@ -130,24 +140,19 @@ code blocks in C-style languages, <C-}> (which is really <C-]>) adds braces on
lines separate from the content.
If t or < is used, Vim prompts for an HTML/XML tag to insert. You may specify
attributes here and they will be stripped from the closing tag. If replacing a
tag, its attributes are kept in the new tag. End your input with > to discard
the those attributes. If <C-T> is used, the tags will appear on lines by
themselves.
If f, F, or <C-F> is used, Vim prompts for a function name to insert. The target
text will be wrapped in a function call. If f is used, the text is wrapped with
() parentheses; F adds additional spaces inside the parentheses. <C-F> inserts the
function name inside the parentheses.
Old text Command New text ~
"hello" ysWfprint<cr> print("hello")
"hello" ysWFprint<cr> print( "hello" )
"hello" ysW<C-f>print<cr> (print "hello")
If s is used, a leading but not trailing space is added. This is useful for
removing parentheses from a function call with csbs.
attributes here and they will be stripped from the closing tag. End your
input by pressing <CR> or >. If <C-T> is used, the tags will appear on lines
by themselves.
A deprecated replacement of a LaTeX environment is provided on \ and l. The
name of the environment and any arguments will be input from a prompt. This
will be removed once a more fully functional customization system is
implemented. The following shows the resulting environment from
csp\tabular}{lc<CR>
>
\begin{tabular}{lc}
\end{tabular}
<
CUSTOMIZING *surround-customizing*
The following adds a potential replacement on "-" (ASCII 45) in PHP files.
@ -202,4 +207,16 @@ that allow you to jump to such markings.
>
let g:surround_insert_tail = "<++>"
<
ISSUES *surround-issues*
Vim could potentially get confused when deleting/changing occurs at the very
end of the line. Please report any repeatable instances of this.
Do we need to use |inputsave()|/|inputrestore()| with the tag replacement?
Indenting is handled haphazardly. Need to decide the most appropriate
behavior and implement it. Right now one can do :let b:surround_indent = 1
(or the global equivalent) to enable automatic re-indenting by Vim via |=|;
should this be the default?
vim:tw=78:ts=8:ft=help:norl:

291
plugin/surround.vim
View file

@ -1,13 +1,28 @@
" surround.vim - Surroundings
" Author: Tim Pope <http://tpo.pe/>
" Version: 2.2
" Author: Tim Pope <vimNOSPAM@tpope.org>
" Version: 1.90
" GetLatestVimScripts: 1697 1 :AutoInstall: surround.vim
"
" See surround.txt for help. This can be accessed by doing
"
" :helptags ~/.vim/doc
" :help surround
"
" Licensed under the same terms as Vim itself.
if exists("g:loaded_surround") || &cp || v:version < 700
" ============================================================================
" Exit quickly when:
" - this plugin was already loaded or disabled
" - when 'compatible' is set
if (exists("g:loaded_surround") && g:loaded_surround) || &cp
finish
endif
let g:loaded_surround = 1
let s:cpo_save = &cpo
set cpo&vim
" Input functions {{{1
function! s:getchar()
@ -21,10 +36,10 @@ endfunction
function! s:inputtarget()
let c = s:getchar()
while c =~ '^\d\+$'
let c .= s:getchar()
let c = c . s:getchar()
endwhile
if c == " "
let c .= s:getchar()
let c = c . s:getchar()
endif
if c =~ "\<Esc>\|\<C-C>\|\0"
return ""
@ -34,9 +49,10 @@ function! s:inputtarget()
endfunction
function! s:inputreplacement()
"echo '-- SURROUND --'
let c = s:getchar()
if c == " "
let c .= s:getchar()
let c = c . s:getchar()
endif
if c =~ "\<Esc>" || c =~ "\<C-C>"
return ""
@ -75,9 +91,19 @@ function! s:extractafter(str)
endif
endfunction
function! s:repeat(str,count)
let cnt = a:count
let str = ""
while cnt > 0
let str = str . a:str
let cnt = cnt - 1
endwhile
return str
endfunction
function! s:fixindent(str,spc)
let str = substitute(a:str,'\t',repeat(' ',&sw),'g')
let spc = substitute(a:spc,'\t',repeat(' ',&sw),'g')
let str = substitute(a:str,'\t',s:repeat(' ',&sw),'g')
let spc = substitute(a:spc,'\t',s:repeat(' ',&sw),'g')
let str = substitute(str,'\(\n\|\%^\).\@=','\1'.spc,'g')
if ! &et
let str = substitute(str,'\s\{'.&ts.'\}',"\t",'g')
@ -87,14 +113,15 @@ endfunction
function! s:process(string)
let i = 0
for i in range(7)
while i < 7
let i = i + 1
let repl_{i} = ''
let m = matchstr(a:string,nr2char(i).'.\{-\}\ze'.nr2char(i))
if m != ''
let m = substitute(strpart(m,1),'\r.*','','')
let repl_{i} = input(match(m,'\w\+$') >= 0 ? m.': ' : m)
let repl_{i} = input(substitute(m,':\s*$','','').': ')
endif
endfor
endwhile
let s = ""
let i = 0
while i < strlen(a:string)
@ -102,7 +129,7 @@ function! s:process(string)
if char2nr(char) < 8
let next = stridx(a:string,char,i+1)
if next == -1
let s .= char
let s = s . char
else
let insertion = repl_{char2nr(char)}
let subs = strpart(a:string,i+1,next-i-1)
@ -113,23 +140,23 @@ function! s:process(string)
let r = stridx(sub,"\r")
let insertion = substitute(insertion,strpart(sub,0,r),strpart(sub,r+1),'')
endwhile
let s .= insertion
let s = s . insertion
let i = next
endif
else
let s .= char
let s = s . char
endif
let i += 1
let i = i + 1
endwhile
return s
endfunction
function! s:wrap(string,char,type,removed,special)
function! s:wrap(string,char,type,...)
let keeper = a:string
let newchar = a:char
let s:input = ""
let type = a:type
let linemode = type ==# 'V' ? 1 : 0
let special = a:0 ? a:1 : 0
let before = ""
let after = ""
if type ==# "V"
@ -137,6 +164,7 @@ function! s:wrap(string,char,type,removed,special)
else
let initspaces = matchstr(getline('.'),'\%^\s*')
endif
" Duplicate b's are just placeholders (removed)
let pairs = "b()B{}r[]a<>"
let extraspace = ""
if newchar =~ '^ '
@ -158,19 +186,13 @@ function! s:wrap(string,char,type,removed,special)
elseif newchar ==# "p"
let before = "\n"
let after = "\n\n"
elseif newchar ==# 's'
let before = ' '
let after = ''
elseif newchar ==# ':'
let before = ':'
let after = ''
elseif newchar =~# "[tT\<C-T><]"
elseif newchar =~# "[tT\<C-T><,]"
let dounmapp = 0
let dounmapb = 0
if !maparg(">","c")
let dounmapb = 1
let dounmapb= 1
" Hide from AsNeeded
exe "cn"."oremap > ><CR>"
exe "cn"."oremap > <CR>"
endif
let default = ""
if newchar ==# "T"
@ -180,29 +202,21 @@ function! s:wrap(string,char,type,removed,special)
let default = matchstr(s:lastdel,'<\zs.\{-\}\ze>')
endif
let tag = input("<",default)
echo "<".substitute(tag,'>*$','>','')
if dounmapb
silent! cunmap >
endif
let s:input = tag
if tag != ""
let keepAttributes = ( match(tag, ">$") == -1 )
let tag = substitute(tag,'>*$','','')
let attributes = ""
if keepAttributes
let attributes = matchstr(a:removed, '<[^ \t\n]\+\zs\_.\{-\}\ze>')
endif
let s:input = tag . '>'
let before = '<'.tag.'>'
if tag =~ '/$'
let tag = substitute(tag, '/$', '', '')
let before = '<'.tag.attributes.' />'
let after = ''
else
let before = '<'.tag.attributes.'>'
let after = '</'.substitute(tag,' .*','','').'>'
endif
if newchar == "\<C-T>"
if newchar == "\<C-T>" || newchar == ","
if type ==# "v" || type ==# "V"
let before .= "\n\t"
let before = before . "\n\t"
endif
if type ==# "v"
let after = "\n". after
@ -212,30 +226,29 @@ function! s:wrap(string,char,type,removed,special)
elseif newchar ==# 'l' || newchar == '\'
" LaTeX
let env = input('\begin{')
let env = '{' . env
let env = env . s:closematch(env)
echo '\begin'.env
if env != ""
let s:input = env."\<CR>"
let env = '{' . env
let env .= s:closematch(env)
echo '\begin'.env
let before = '\begin'.env
let after = '\end'.matchstr(env,'[^}]*').'}'
endif
"if type ==# 'v' || type ==# 'V'
"let before = before ."\n\t"
"endif
"if type ==# 'v'
"let after = "\n".initspaces.after
"endif
elseif newchar ==# 'f' || newchar ==# 'F'
let fnc = input('function: ')
if fnc != ""
let s:input = fnc."\<CR>"
let before = substitute(fnc,'($','','').'('
let after = ')'
if newchar ==# 'F'
let before .= ' '
let after = ' ' . after
let before = before . ' '
let after = ' ' . after
endif
endif
elseif newchar ==# "\<C-F>"
let fnc = input('function: ')
let s:input = fnc."\<CR>"
let before = '('.fnc.' '
let after = ')'
elseif idx >= 0
let spc = (idx % 3) == 1 ? " " : ""
let idx = idx / 3 * 3
@ -251,28 +264,25 @@ function! s:wrap(string,char,type,removed,special)
let before = ''
let after = ''
endif
"let before = substitute(before,'\n','\n'.initspaces,'g')
let after = substitute(after ,'\n','\n'.initspaces,'g')
if type ==# 'V' || (a:special && type ==# "v")
"let after = substitute(after,"\n\\s*\<C-U>\\s*",'\n','g')
if type ==# 'V' || (special && type ==# "v")
let before = substitute(before,' \+$','','')
let after = substitute(after ,'^ \+','','')
if after !~ '^\n'
let after = initspaces.after
endif
if keeper !~ '\n$' && after !~ '^\n'
let keeper .= "\n"
let keeper = keeper . "\n"
elseif keeper =~ '\n$' && after =~ '^\n'
let after = strpart(after,1)
endif
if keeper !~ '^\n' && before !~ '\n\s*$'
let before .= "\n"
if a:special
let before .= "\t"
if before !~ '\n\s*$'
let before = before . "\n"
if special
let before = before . "\t"
endif
elseif keeper =~ '^\n' && before =~ '\n\s*$'
let keeper = strcharpart(keeper,1)
endif
if type ==# 'V' && keeper =~ '\n\s*\n$'
let keeper = strcharpart(keeper,0,strchars(keeper) - 1)
endif
endif
if type ==# 'V'
@ -300,31 +310,35 @@ function! s:wrap(string,char,type,removed,special)
return keeper
endfunction
function! s:wrapreg(reg,char,removed,special)
function! s:wrapreg(reg,char,...)
let orig = getreg(a:reg)
let type = substitute(getregtype(a:reg),'\d\+$','','')
let new = s:wrap(orig,a:char,type,a:removed,a:special)
let special = a:0 ? a:1 : 0
let new = s:wrap(orig,a:char,type,special)
call setreg(a:reg,new,type)
endfunction
" }}}1
function! s:insert(...) " {{{1
" Optional argument causes the result to appear on 3 lines, not 1
"call inputsave()
let linemode = a:0 ? a:1 : 0
let char = s:inputreplacement()
while char == "\<CR>" || char == "\<C-S>"
" TODO: use total count for additional blank lines
let linemode += 1
let linemode = linemode + 1
let char = s:inputreplacement()
endwhile
"call inputrestore()
if char == ""
return ""
endif
"call inputsave()
let cb_save = &clipboard
set clipboard-=unnamed clipboard-=unnamedplus
set clipboard-=unnamed
let reg_save = @@
call setreg('"',"\032",'v')
call s:wrapreg('"',char,"",linemode)
call setreg('"',"\r",'v')
call s:wrapreg('"',char,linemode)
" If line mode is used and the surrounding consists solely of a suffix,
" remove the initial newline. This fits a use case of mine but is a
" little inconsistent. Is there anyone that would prefer the simpler
@ -336,16 +350,10 @@ function! s:insert(...) " {{{1
if exists("g:surround_insert_tail")
call setreg('"',g:surround_insert_tail,"a".getregtype('"'))
endif
if &ve != 'all' && col('.') >= col('$')
if &ve == 'insert'
let extra_cols = virtcol('.') - virtcol('$')
if extra_cols > 0
let [regval,regtype] = [getreg('"',1,1),getregtype('"')]
call setreg('"',join(map(range(extra_cols),'" "'),''),'v')
norm! ""p
call setreg('"',regval,regtype)
endif
endif
"if linemode
"call setreg('"',substitute(getreg('"'),'^\s\+','',''),'c')
"endif
if col('.') >= col('$')
norm! ""p
else
norm! ""P
@ -354,21 +362,19 @@ function! s:insert(...) " {{{1
call s:reindent()
endif
norm! `]
call search("\032",'bW')
call search('\r','bW')
let @@ = reg_save
let &clipboard = cb_save
return "\<Del>"
endfunction " }}}1
function! s:reindent() abort " {{{1
if get(b:, 'surround_indent', get(g:, 'surround_indent', 1)) && (!empty(&equalprg) || !empty(&indentexpr) || &cindent || &smartindent || &lisp)
function! s:reindent() " {{{1
if exists("b:surround_indent") ? b:surround_indent : (exists("g:surround_indent") && g:surround_indent)
silent norm! '[=']
endif
endfunction " }}}1
function! s:dosurround(...) " {{{1
let sol_save = &startofline
set startofline
let scount = v:count1
let char = (a:0 ? a:1 : s:inputtarget())
let spc = ""
@ -390,14 +396,11 @@ function! s:dosurround(...) " {{{1
if a:0 > 1
let newchar = a:2
if newchar == "\<Esc>" || newchar == "\<C-C>" || newchar == ""
if !sol_save
set nostartofline
endif
return s:beep()
endif
endif
let cb_save = &clipboard
set clipboard-=unnamed clipboard-=unnamedplus
set clipboard-=unnamed
let append = ""
let original = getreg('"')
let otype = getregtype('"')
@ -405,12 +408,6 @@ function! s:dosurround(...) " {{{1
let strcount = (scount == 1 ? "" : scount)
if char == '/'
exe 'norm! '.strcount.'[/d'.strcount.']/'
elseif char =~# '[[:punct:][:space:]]' && char !~# '[][(){}<>"''`]'
exe 'norm! T'.char
if getline('.')[col('.')-1] == char
exe 'norm! l'
endif
exe 'norm! dt'.char
else
exe 'norm! d'.strcount.'i'.char
endif
@ -419,9 +416,6 @@ function! s:dosurround(...) " {{{1
if keeper == ""
call setreg('"',original,otype)
let &clipboard = cb_save
if !sol_save
set nostartofline
endif
return ""
endif
let oldline = getline('.')
@ -438,12 +432,9 @@ function! s:dosurround(...) " {{{1
norm! "_x
call setreg('"','/**/',"c")
let keeper = substitute(substitute(keeper,'^/\*\s\=','',''),'\s\=\*$','','')
elseif char =~# '[[:punct:][:space:]]' && char !~# '[][(){}<>]'
exe 'norm! F'.char
exe 'norm! df'.char
else
" One character backwards
call search('\m.', 'bW')
call search('.','bW')
exe "norm! da".char
endif
let removed = getreg('"')
@ -455,7 +446,7 @@ function! s:dosurround(...) " {{{1
let keeper = substitute(keeper,'^\s\+','','')
let keeper = substitute(keeper,'\s\+$','','')
endif
if col("']") == col("$") && virtcol('.') + 1 == virtcol('$')
if col("']") == col("$") && col('.') + 1 == col('$')
if oldhead =~# '^\s*$' && a:0 < 2
let keeper = substitute(keeper,'\%^\n'.oldhead.'\(\s*.\{-\}\)\n\s*\%$','\1','')
endif
@ -463,13 +454,12 @@ function! s:dosurround(...) " {{{1
else
let pcmd = "P"
endif
if line('.') + 1 < oldlnum && regtype ==# "V"
if line('.') < oldlnum && regtype ==# "V"
let pcmd = "p"
endif
call setreg('"',keeper,regtype)
if newchar != ""
let special = a:0 > 2 ? a:3 : 0
call s:wrapreg('"',newchar,removed,special)
call s:wrapreg('"',newchar)
endif
silent exe 'norm! ""'.pcmd.'`['
if removed =~ '\n' || okeeper =~ '\n' || getreg('"') =~ '\n'
@ -478,20 +468,17 @@ function! s:dosurround(...) " {{{1
if getline('.') =~ '^\s\+$' && keeper =~ '^\s*\n'
silent norm! cc
endif
call setreg('"',original,otype)
call setreg('"',removed,regtype)
let s:lastdel = removed
let &clipboard = cb_save
if newchar == ""
silent! call repeat#set("\<Plug>Dsurround".char,scount)
else
silent! call repeat#set("\<Plug>C".(a:0 > 2 && a:3 ? "S" : "s")."urround".char.newchar.s:input,scount)
endif
if !sol_save
set nostartofline
silent! call repeat#set("\<Plug>Csurround".char.newchar,scount)
endif
endfunction " }}}1
function! s:changesurround(...) " {{{1
function! s:changesurround() " {{{1
let a = s:inputtarget()
if a == ""
return s:beep()
@ -500,14 +487,10 @@ function! s:changesurround(...) " {{{1
if b == ""
return s:beep()
endif
call s:dosurround(a,b,a:0 && a:1)
call s:dosurround(a,b)
endfunction " }}}1
function! s:opfunc(type, ...) abort " {{{1
if a:type ==# 'setup'
let &opfunc = matchstr(expand('<sfile>'), '<SNR>\w\+$')
return 'g@'
endif
function! s:opfunc(type,...) " {{{1
let char = s:inputreplacement()
if char == ""
return s:beep()
@ -516,9 +499,10 @@ function! s:opfunc(type, ...) abort " {{{1
let sel_save = &selection
let &selection = "inclusive"
let cb_save = &clipboard
set clipboard-=unnamed clipboard-=unnamedplus
set clipboard-=unnamed
let reg_save = getreg(reg)
let reg_type = getregtype(reg)
"call setreg(reg,"\n","c")
let type = a:type
if a:type == "char"
silent exe 'norm! v`[o`]"'.reg.'y'
@ -527,7 +511,6 @@ function! s:opfunc(type, ...) abort " {{{1
silent exe 'norm! `[V`]"'.reg.'y'
let type = 'V'
elseif a:type ==# "v" || a:type ==# "V" || a:type ==# "\<C-V>"
let &selection = sel_save
let ve = &virtualedit
if !(a:0 && a:1)
set virtualedit=
@ -552,7 +535,7 @@ function! s:opfunc(type, ...) abort " {{{1
let keeper = substitute(keeper,'\_s\@<!\s*$','','')
endif
call setreg(reg,keeper,type)
call s:wrapreg(reg,char,"",a:0 && a:1)
call s:wrapreg(reg,char,a:0 && a:1)
if type ==# "v" && a:type !=# "v" && append != ""
call setreg(reg,append,"ac")
endif
@ -564,18 +547,12 @@ function! s:opfunc(type, ...) abort " {{{1
let &selection = sel_save
let &clipboard = cb_save
if a:type =~ '^\d\+$'
silent! call repeat#set("\<Plug>Y".(a:0 && a:1 ? "S" : "s")."surround".char.s:input,a:type)
else
silent! call repeat#set("\<Plug>SurroundRepeat".char.s:input)
silent! call repeat#set("\<Plug>Y".(a:0 && a:1 ? "S" : "s")."surround".char,a:type)
endif
endfunction
function! s:opfunc2(...) abort
if !a:0 || a:1 ==# 'setup'
let &opfunc = matchstr(expand('<sfile>'), '<SNR>\w\+$')
return 'g@'
endif
call s:opfunc(a:1, 1)
function! s:opfunc2(arg)
call s:opfunc(a:arg,1)
endfunction " }}}1
function! s:closematch(str) " {{{1
@ -594,37 +571,55 @@ function! s:closematch(str) " {{{1
endif
endfunction " }}}1
nnoremap <silent> <Plug>SurroundRepeat .
nnoremap <silent> <Plug>Dsurround :<C-U>call <SID>dosurround(<SID>inputtarget())<CR>
nnoremap <silent> <Plug>Csurround :<C-U>call <SID>changesurround()<CR>
nnoremap <silent> <Plug>CSurround :<C-U>call <SID>changesurround(1)<CR>
nnoremap <expr> <Plug>Yssurround '^'.v:count1.<SID>opfunc('setup').'g_'
nnoremap <expr> <Plug>YSsurround <SID>opfunc2('setup').'_'
nnoremap <expr> <Plug>Ysurround <SID>opfunc('setup')
nnoremap <expr> <Plug>YSurround <SID>opfunc2('setup')
nnoremap <silent> <Plug>Yssurround :<C-U>call <SID>opfunc(v:count1)<CR>
nnoremap <silent> <Plug>YSsurround :<C-U>call <SID>opfunc2(v:count1)<CR>
" <C-U> discards the numerical argument but there's not much we can do with it
nnoremap <silent> <Plug>Ysurround :<C-U>set opfunc=<SID>opfunc<CR>g@
nnoremap <silent> <Plug>YSurround :<C-U>set opfunc=<SID>opfunc2<CR>g@
vnoremap <silent> <Plug>Vsurround :<C-U>call <SID>opfunc(visualmode())<CR>
vnoremap <silent> <Plug>VSurround :<C-U>call <SID>opfunc(visualmode(),visualmode() ==# 'V' ? 1 : 0)<CR>
vnoremap <silent> <Plug>VgSurround :<C-U>call <SID>opfunc(visualmode(),visualmode() ==# 'V' ? 0 : 1)<CR>
inoremap <silent> <Plug>Isurround <C-R>=<SID>insert()<CR>
inoremap <silent> <Plug>ISurround <C-R>=<SID>insert(1)<CR>
if !exists("g:surround_no_mappings") || ! g:surround_no_mappings
nmap ds <Plug>Dsurround
nmap cs <Plug>Csurround
nmap cS <Plug>CSurround
nmap ys <Plug>Ysurround
nmap yS <Plug>YSurround
nmap yss <Plug>Yssurround
nmap ySs <Plug>YSsurround
nmap ySS <Plug>YSsurround
xmap S <Plug>VSurround
xmap gS <Plug>VgSurround
if !exists("g:surround_no_insert_mappings") || ! g:surround_no_insert_mappings
if !hasmapto("<Plug>Isurround","i") && "" == mapcheck("<C-S>","i")
imap <C-S> <Plug>Isurround
nmap ds <Plug>Dsurround
nmap cs <Plug>Csurround
nmap ys <Plug>Ysurround
nmap yS <Plug>YSurround
nmap yss <Plug>Yssurround
nmap ySs <Plug>YSsurround
nmap ySS <Plug>YSsurround
if !hasmapto("<Plug>Vsurround","v") && !hasmapto("<Plug>VSurround","v")
if exists(":xmap")
xmap s <Plug>Vsurround
else
vmap s <Plug>Vsurround
endif
imap <C-G>s <Plug>Isurround
imap <C-G>S <Plug>ISurround
endif
if !hasmapto("<Plug>VSurround","v")
if exists(":xmap")
xmap S <Plug>VSurround
else
vmap S <Plug>VSurround
endif
endif
if exists(":xmap")
xmap gS <Plug>VgSurround
else
vmap gS <Plug>VgSurround
endif
if !hasmapto("<Plug>Isurround","i") && "" == mapcheck("<C-S>","i")
imap <C-S> <Plug>Isurround
endif
imap <C-G>s <Plug>Isurround
imap <C-G>S <Plug>ISurround
"Implemented internally instead
"imap <C-S><C-S> <Plug>ISurround
endif
let &cpo = s:cpo_save
" vim:set ft=vim sw=2 sts=2 et: