Keybinding to ASCII characters

[fdncred]

I'm trying to understand rustyline's keybindings better because I'm not sure what we have implemented in nushell is working.

This backspaces a character at a time. It seems like it should backspace a word at a time.

    rl.bind_sequence(
        KeyPress::Char('\x08'), // The ASCII code for backspace is 08
        Cmd::Kill(Movement::BackwardWord(1, Word::Vi)),
        );

This backspaces a word at a time. I think that is correct.

    rl.bind_sequence(
        KeyPress::Backspace,
        Cmd::Kill(Movement::BackwardWord(1, Word::Vi)),
        );

This backspaces a character at a time. It seems like this should backspace a word at a time with ctrl+backspace.

    rl.bind_sequence(
        KeyPress::Ctrl('\x08'), // The ASCII code for backspace is 08
        Cmd::Kill(Movement::BackwardWord(1, Word::Vi)),
        );

Any ideas why only the middle one seems to work?

[gwenn]

Because of this:

        '\x08' => KeyPress::Backspace, // '\b'

Control characters received from stdin are "normalized" before looking for associated command.

[fdncred]

Right. I've seen that. So there is no way to use char literals for keybindings?

[gwenn]

And I guess we cannot retrieved a Ctrl-backspace from a Unix terminal.
See #318 (comment) and #333

[gwenn]

You may already know but you can patch this example.
And then run:

RUST_LOG=rustyline=debug cargo run --example example 2> debug.log
# tail -f debug.log in another terminal...

to trace all keys pressed.

[fdncred]

oh, I didn't know that. Thanks for the tip!

[gwenn]

Right. I've seen that. So there is no way to use char literals for keybindings?

We should (have) "normalize" the first parameter of bind_sequence (KeyPress::Char('\x08') => KeyPress::Backspace) and warn if one binding is overwritten after normalisation.

[fdncred]

We want to be able to bind Ctrl + Backspace to Cmd::Kill::BackwardWord(1) and Alt + Backspace to Cmd::Kill::BackwardChar(1). I see no way to do that at all. Even if I hard code it, it doesn't work.

[gwenn]

We want to be able to bind Ctrl + Backspace to Cmd::Kill::BackwardWord(1) and Alt + Backspace to Cmd::Kill::BackwardChar(1). I see no way to do that at all. Even if I hard code it, it doesn't work.

For me, you cannot retrieve a Ctrl-backspace from a Unix terminal so I would prefer to keep it as unsupported (even if it is possible on Windows).

[gwenn]

Right. I've seen that. So there is no way to use char literals for keybindings?

We should (have) "normalize" the first parameter of bind_sequence (KeyPress::Char('\x08') => KeyPress::Backspace) and warn if one binding is overwritten after normalisation.

Something like:

diff --git a/src/lib.rs b/src/lib.rs
index faa8da0..968fb87 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -887,7 +887,21 @@ impl<H: Helper> Editor<H> {
     /// Bind a sequence to a command.
     pub fn bind_sequence(&mut self, key_seq: KeyPress, cmd: Cmd) -> Option<Cmd> {
         if let Ok(mut bindings) = self.custom_bindings.write() {
-            bindings.insert(key_seq, cmd)
+            let key = if let KeyPress::Char(ref c) = key_seq {
+                if c.is_control() {
+                    keys::char_to_key_press(*c)
+                } else {
+                    key_seq
+                }
+            } else if let KeyPress::Ctrl(ref c) = key_seq {
+                if c.is_control() {
+                    warn!(target: "rustyline", "KeyPress::Ctrl({:?}) may not work on unix", c)
+                }
+                key_seq
+            } else {
+                key_seq
+            };
+            bindings.insert(key, cmd)
         } else {
             None
         }

[fdncred]

what would be even better, is to allow the windows customization, and warn like you do here. Also, vice-versa, i assume there are keys that unix can bind that windows cannot.

[gwenn]

If you want to support Ctrl-backspace on windows, you will have to fix that:

} else if key == KeyPress::Backspace && ctrl {
...

(not tested)

[fdncred]

Here's a PR to look at for this stuff.

[gwenn]

Version 7.0.0 released