vim-sandwich

sandwich.vim

Quick start

Add

Press

sa{motion/textobject}{addition}

saiw(

Delete

Press

sdb

sd{deletion}

sdb

sd(

sdb

Replace

Press

srb{addition}

sr{deletion}{addition}

srb"

sr("

That's all. Now you already know enough about

sandwich.vim

sandwich.vim

Design

This plugin provides functions to add/delete/replace surroundings of a sandwiched text. These functions are implemented genuinely by utilizing operator/textobject framework. Thus their action can be repeated by

.

operator-sandwich

A sandwiched text could be resolved into two parts, {surrounding} and {surrounded text}.

• Add surroundings: mapped to the key sequence

  sa

  • {surrounded text} ---> {surrounding}{surrounded text}{surrounding}

• Delete surroundings: mapped to the key sequence

  sd

  • {surrounding}{surrounded text}{surrounding} ---> {surrounded text}

• Replace surroundings: mapped to the key sequence

  sr

  • {surrounding}{surrounded text}{surrounding} ---> {new surrounding}{surrounded text}{new surrounding}

textobj-sandwich

• Search and select a sandwiched text automatically: mapped to the key sequence

  ib

  and

  ab

• Search and select a sandwiched text with query: mapped to the key sequence

  is

  and

  as

ib

is

ab

as

             ||
{surrounding}{surrounded text}{surrounding}
||

Configuration

The point is that it would be nice to be shared the definitions of {surrounding}s pairs in all kinds of operations. User can freely add new settings to extend the functionality. If

g:sandwich#recipes

g:sandwich#default_recipes

vim
let g:sandwich#recipes = deepcopy(g:sandwich#default_recipes)

recipe

buns

For example: {'buns': ['(', ')']} foo ---> (foo) ```

Or there is a different way, use external textobjects to define {surrounding}s from the difference of two textobjects. ``` let g:sandwich#recipes += [{'external': [{textobj-i}, {textobj-a}], 'option-name1': {value1}, 'option-name2': {value} ...}]

For example: {'external': ['it', 'at']}

Features

Unique count handling

As for the default operators, the possible key input in normal mode is like this.

        [count1]{operator}[count2]{textobject}

[count1]

[count2]

[count1]

{operators}

[count2]

{textobject}

Linewise and blockwise operations

Operator-sandwich works linewise with the linewise-visual selection and linewise motions.

" press Vsa(
    foo  --->  (
               foo
               )

Using

command

let g:sandwich#recipes += [
      \   {
      \     'buns'        : ['{', '}'],
      \     'motionwise'  : ['line'],
      \     'kind'        : ['add'],
      \     'linewise'    : 1,
      \     'command'     : ["'[+1,']-1normal! >>"],
      \   },
      \   {
      \     'buns'        : ['{', '}'],
      \     'motionwise'  : ['line'],
      \     'kind'        : ['delete'],
      \     'linewise'    : 1,
      \     'command'     : ["'[,']normal! <  {
                   foo
                 }

" press V2jsd
    {      --->  foo
      foo
    }

Operator-sandwich also can work blockwise with the blockwise-visual selection and blockwise motions.

" press 2j2lsa(
    foo        (foo)
    bar  --->  (bar)
    baz        (baz)

There is an option to skip white space

skip_space

" press 3j$sa(
    fooooooo            (fooooooo)
      baaaar   --->       (baaaar)

baaaz               (baaaz)

Expression surroundings and regular expression matching

The option

expr

buns

let g:sandwich#recipes += [
      \   {
      \     'buns'    : ['TagInput(1)', 'TagInput(0)'],
      \     'expr'    : 1,
      \     'filetype': ['html'],
      \     'kind'    : ['add', 'replace'],
      \     'action'  : ['add'],
      \     'input'   : ['t'],
      \   },
      \ ]

function! TagInput(is_head) abort
  if a:is_head
    let s:TagLast = input('Tag: ')
    if s:TagLast !=# ''
      let tag = printf('', s:TagLast)
    else
      throw 'OperatorSandwichCancel'
    endif
  else
    let tag = printf('%s>', matchstr(s:TagLast, '^\a[^[:blank:]>/]*'))
  endif
  return tag
endfunction

The option

regex

buns

let g:sandwich#recipes += [
      \   {
      \     'buns'    : ['/]*.\{-}>',
      \                  '\a[^[:blank:]>/]*>'],
      \     'regex'   : 1,
      \     'filetype': ['html'],
      \     'nesting' : 1,
      \     'input'   : ['t'],
      \   },
      \ ]

However the above example is not so accurate. Instead of the example, there are excellent built-in textobjects

it

at

external

let g:sandwich#recipes += [
      \   {
      \     'external': ['it', 'at'],
      \     'noremap' : 1,
      \     'filetype': ['html'],
      \     'input'   : ['t'],
      \   },
      \ ]

Demo

Pioneers

• vim-surround
• vim-operator-surround
• vim-textobj-multiblock
• vim-textobj-anyblock
• vim-textobj-between