How to kill forward until the end of a big word or to next space character

readline

I can not wrap my head finding a solution for this simple editing task in Readline.
I just want to kill the characters forward until the end of a Big word, that is, (more or less) until the next space character (dE in vim).

Specially, when hitting a key sequence,

> 2234I567.890 32345678

would become

> 2234I 32345678

where the cursor position is indicated by I.

Here are what I've tried to add in ~/.inputrc to make it happen.

First attempt:
```
"\eF": vi-fWord
"\eD": "\eF\C-w"
```

This does kill forward for a Big word, but it works incorrectly
if the cursor is placed in word. In that case, the whole word is killed.

Second attempt:

"\eF": vi-fWord
"\C-x1": kill-region
"\eD": "\C-@\eF\C-x1 "

This should have worked, shouldn't it? At least it works if I manually kick the
complete \C-@\eF\C-x1 key sequence myself on the commandline.
However it was weird that nothing happened when I kicked \eD key sequence.

I also thought about using vi mode command vi-delete-to and the likes, but not sure how to do it due to the complete lack of documentation relating to
Readline vi mode.

So I'm here to seek help.

Best Answer

OK, I have got it work finally.

It turns out that I just have to remap set-mark function to another key sequence (say, \C-x2) and replace the default \C-@ with this new mapping. Then everything works just fine.

Maybe it's a bug that \C-@ doesn't function as expected when appearing in RHS of a Readline macro.

The following is my setup that makes Alt + D delete input forward to the next space or big WORD (in vim jargon).

"\C-x0": vi-eWord
"\C-x1": kill-region
"\C-x2": set-mark
"\eF": "\C-x0\C-f"
"\eD": "\C-x2\eF\C-x1"

Because we didn't use shell-specific Readline function such as shell-forward-word, the key binding works in all applications that utilize Readline library, for example, bash, (i)python, etc.

Related Solutions

Bash – Deleting input forward to the next space

If you're an Emacs user, my answer probably isn't something you'll want to use, but it should still be noted on this page so here it is:

You can use vi keybindings in a bash shell very easily. Type set -o vi. Add it to your .bashrc if you like the results.

The answer to your specific question, delete forward to the next space, is accomplished with dt<Space> (delete till space) or just dE (delete to end of space-delimited Word).

Standard vi keybindings are used—the main thing to get used to (if you're a vi user already) is that you'll be in insert mode by default. So to use a Normal-mode command such as the above, type <Esc> first. Alternatively, you can hold down the Alt key while typing the first letter of your command. For instance, k is the vi command to go up one line, so <Alt>k can be used just like the up arrow—to go back one command in your history.

Bash – How to print out the delimiter character and allow user to edit line while reading standard input

I'd use zsh where the line editor has many more capabilities and is a lot more customizable:

#! /bin/zsh -
insert-and-accept() {
  zle self-insert
  # RBUFFER= # to discard everything on the right
  zle accept-line
}
zle -N insert-and-accept
bindkey ";" insert-and-accept
bindkey "^M" self-insert
vared -p "><> " -c srcCommand

With bash-4.3 or above, you can do something similar with a hack like:

# bind ; to ^Z^C (^Z, ^C otherwide bypass the key binding when entered
# on the keyboard). Redirect stderr to /dev/null to discard the
# useless warning
bind '";":"\32\3"' 2> /dev/null

# new widget that inserts ";" at the end of the buffer.
# If we did bind '";":";\3"', readline would loop indefinitely
add_semicolon() {
  READLINE_LINE+=";"
  ((READLINE_POINT++))
}
# which we bind to ^Z
bind -x '"\32":add_semicolon' 2> /dev/null

# read until the ^C
read -e -d $'\3' -t 180 -p '><> ' srcCommand

Note that in that version, the ; is always inserted at the end of the input buffer, not at the current cursor position. Change the add_semicolon to:

add_semicolon() {
  READLINE_LINE="${READLINE_LINE:0:READLINE_POINT++};"
}

If you want it inserted at the cursor and everything on the right discarded. Or:

add_semicolon() {
  READLINE_LINE="${READLINE_LINE:0:READLINE_POINT};${READLINE_LINE:READLINE_POINT}"
  READLINE_POINT=${#READLINE_LINE}
}

if you want to insert it at the cursor but want to preserve what's on the right like in the zsh approach.

If you don't want the ; in $srcCommand, you can always strip it afterwards with srcCommand="${srcComman//;}" for instance, but you'd need to insert it in the widget for it to be displayed by zle/readline.