This commit adds the ability to complete the current line with the word of the hint. When the cursor is at the end of the current line and CTRL + right arrow has been pressed, the next word of the hint will be added to the editor's line.

Closes #413

This commit implements CTRL-V support on Windows. See #519 where this issue was raised.

Implementation notes

On Windows, we have 3 key changes:

• There are new Windows-only dependencies on the clipboard-win and error-code crates.
• tty/windows.rs implements read_pasted_text by calling the clipboard-win crate. Errors are mapped to a new Windows-only error variant.
• When CTRL-V is pressed, QuotedInsert will perform a yank using the text from the clipboard (inserting the text and moving the cursor).

Testing

I made a new package:

cargo new testpaste
cd testpaste
cargo add rustyline
# edit Cargo.toml; make rustyline use my git fork
# edit src/lib.rs to be the contents of https://github.com/kkawakam/rustyline#example

As noted in #519, running this example in Windows Terminal works (CTRL-V pastes text from the system clipboard) while using Powershell or cmd.exe does not work (CTRL-V does nothing, while rightclick pastes text from the system clipboard).

After this change, CTRL-V works in all 3 shells. Mouse rightclick continues to work.

Other

See #520 for why I reverted the change to use fd-lock.

Sample program:

use rustyline::{Editor,error::ReadlineError};

fn main() {
    let mut e: Editor<()> = Editor::new();

    loop {
        let rl = e.readline("$ ");
        match rl {
            Ok(_) => {
                print!("text\nwithout\nnewline");
            }
            Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => break,
            Err(err) => panic!(err),
        }
    }
}

Expected output:

$ some text here
text
without
newline$ some other

Actual output:

$ some text here
text
without
$ some other

Microsoft Terminal now supports bracketed paste.

Can enable_bracketed_paste support be added to Windows targets as well? Right now, support is only for Unix environments.

See #229

cargo run --example external_print

To do:

• ~~Windows platform (only one printer supported, and when the printer is dropped we still wait)~~
• Check interaction with history search, completion, ...

56b925c271b56da77e7a78a64470e239bc1daa09 breaks the build on my Windows machine.

   Compiling dirs-next v2.0.0
error[E0308]: mismatched types
  --> C:\Users\...\.cargo\registry\src\github.com-1ecc6299db9ec823\fd-lock-2.0.0\src\windows.rs:39:33
   |
39 |         if unsafe { !UnlockFile(handle, 0, 0, 1, 0) } == 0 {
   |                                 ^^^^^^ expected enum `winapi::ctypes::c_void`, found enum `std::ffi::c_void`
   |
   = note: expected raw pointer `*mut winapi::ctypes::c_void`
              found raw pointer `*mut std::ffi::c_void`

error[E0308]: mismatched types
  --> C:\Users\...\.cargo\registry\src\github.com-1ecc6299db9ec823\fd-lock-2.0.0\src\windows.rs:73:35
   |
73 |         match unsafe { LockFileEx(handle, flags, 0, 1, 0, overlapped.raw()) } {
   |                                   ^^^^^^ expected enum `winapi::ctypes::c_void`, found enum `std::ffi::c_void`
   |
   = note: expected raw pointer `*mut winapi::ctypes::c_void`
              found raw pointer `*mut std::ffi::c_void`

error[E0308]: mismatched types
  --> C:\Users\...\.cargo\registry\src\github.com-1ecc6299db9ec823\fd-lock-2.0.0\src\windows.rs:90:33
   |
90 |         match unsafe { LockFile(handle, 0, 0, 1, 0) } {
   |                                 ^^^^^^ expected enum `winapi::ctypes::c_void`, found enum `std::ffi::c_void`
   |
   = note: expected raw pointer `*mut winapi::ctypes::c_void`
              found raw pointer `*mut std::ffi::c_void`

Repro:

> cargo run --example example
1> [now hold enter here]

Once you hold enter, after a few seconds you'll see:

1> 
Line: 
2> 
Line: 
3> 
Line: 
4> 
Line: 
5> 
Line: 

Error: Io(Kind(InvalidData))

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?

What's the secret sauce to get either of these to work in the custom_key_bindings example in Windows Terminal? Am I specifying the handler wrong?

    // rl.bind_sequence(
    //     KeyEvent {
    //         0: KeyCode::Char('H'),
    //         1: Modifiers::CTRL,
    //     },
    //     Cmd::Kill(Movement::BackwardChar(1)),
    // );

    rl.bind_sequence(KeyEvent::ctrl('h'), Cmd::Kill(Movement::BackwardChar(1)));

On Unix, users expect to configure the character they type to cause SIGINT to be sent to the foreground process group by typing, e.g. stty intr ^X where ^X is the key combination they wish to use.

rustyline doesn't use signal handling, turns off ISIG, and hardwires Ctrl-C as the interrupt character. Likewise, the functionality of the VSUSP character (by default Ctrl-Z) appears hardwired as well.

It may be better for it to query the terminal as to which character the user prefers to use and then implement the corresponding actions when it encounters these characters.

PS: this behavior appears to be inherited from the original "guerrilla" linenoise library.

When in insert mode, you have to wait for 500ms (or whatever timeout was given in the editor config). I would expect hitting the escape key to return to command mode immediately.

Thanks for making rustyline! I've been enjoying it.

I see the docs for LineBuffer but I can't seem to find a way to obtain one. Looking through the source, it seems none of its usages are exposed (that I can tell), but LineBuffer itself is exposed, which makes me think there's some way to access it...I just can't figure out what it is!

I have been figuring out how to test the following basic CLI app that uses rustyline using std::process::Command but I could not figure out how to pull it off right.

The following is the code for CLI app:

use std::io::Write;

use rustyline::error::ReadlineError;
use rustyline::Editor;

fn main() {
    let mut line_editor = Editor::<()>::new().unwrap();
    let mut counter = 0;

    loop {
        let readline = line_editor.readline("> ");
        match readline {
            Ok(line) => {
                counter += 1;
                println!("Line: {}", line);
                line_editor.add_history_entry(line.clone());

                if line == "clear" {
                    print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
                    std::io::stdout().flush().unwrap();
                }
            }
            Err(ReadlineError::Interrupted) => {
                println!("Ctrl+C");
                break;
            }
            Err(ReadlineError::Eof) => {
                println!("Ctrl+D | Lines counted: {}", counter);
                break;
            }
            Err(err) => {
                println!("Error: {:?}", err);
                break;
            }
        }
    }
}

And code for the test:

#[test]
fn clear_screen() -> Result<(), Box<dyn std::error::Error>> {
    let mut cmd = Command::cargo_bin("control-cli")?;
    let mut cmd_child = cmd.stdin(Stdio::piped()).spawn()?;
    let mut child_stdin = cmd_child.stdin.take().unwrap();

    child_stdin.write_all(b"history\n").unwrap();

    signal::kill(Pid::from_raw(cmd_child.id() as i32), Signal::SIGINT)?;

    let output = cmd.output()?;

    println!("{}", String::from_utf8_lossy(&output.stdout));

    Ok(())
}

When I run the test with cargo test -- --nocapture, I only get the following output:

Ctrl+D | Lines counted: 0

I was expecting something like:

Line: history
Ctrl+D | Lines counted: 1

I believe #504 may be related to this problem. Nevertheless, how can I achieve the second output?

I am using code from https://github.com/kkawakam/rustyline/blob/master/examples/input_multiline.rs and it does not compile on my system. I can't understand the error here:

error[E0308]: mismatched types
   --> src\cli.rs:52:28
    |
52  |         rl.set_helper(Some(h));
    |                       ---- ^ expected `()`, found struct `InputValidator`
    |                       |
    |                       arguments to this enum variant are incorrect
    |
note: tuple variant defined here
   --> C:\Users\turtle\.rustup\toolchains\nightly-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\option.rs:526:5
    |
526 |     Some(#[stable(feature = "rust1", since = "1.0.0")] T),
    |     ^^^^

Here's my code:

    use rustyline::{error::ReadlineError, Editor};
    use rustyline::validate::MatchingBracketValidator;
    use rustyline::{Cmd, EventHandler, KeyCode, KeyEvent, Modifiers};
    use rustyline_derive::{Completer, Helper, Highlighter, Hinter, Validator};

    #[derive(Completer, Helper, Highlighter, Hinter, Validator)]
    struct InputValidator {
        #[rustyline(Validator)]
        brackets: MatchingBracketValidator,
    }

    #[allow(unreachable_code)]
    pub(crate) fn start_repl() -> std::io::Result<()> {
        let mut buf = String::new();
        let h = InputValidator {
            brackets: MatchingBracketValidator::new(),
        };
        let mut rl = Editor::<()>::new();
        rl.set_helper(Some(h));
        rl.bind_sequence(
            KeyEvent(KeyCode::Char('s'), Modifiers::CTRL),
            EventHandler::Simple(Cmd::Newline),
        );
        if rl.load_history("history.txt").is_err() {
            // println!("No previous history.");
        }
        loop {
            let line = rl.readline("> ");
            match line {
                Ok(line) => {
                    rl.add_history_entry(line.as_str());
                    buf = line;
                }
                Err(ReadlineError::Interrupted) => {
                    println!("CTRL-C");
                    println!("Exiting");
                    std::process::exit(0);
                    break;
                }
                Err(ReadlineError::Eof) => {
                    println!("CTRL-D");
                    break;
                }
                Err(e) => {
                    eprintln!("Unexpected prompt error : {e:?}");
                    std::process::exit(1);
                }
            }
            let input: &str = buf.trim();
            if input == "exit" || input == "quit" {
                println!("Exiting");
                std::process::exit(0);
            }
            buf.clear();
        }
        Ok(())
    }

See FIXME comment here: https://github.com/kkawakam/rustyline/blob/4d48e58913dbc554e8381158d0dc27ec3d8a7559/src/highlight.rs#L45

What's the reason this isn't fixed? Can it be fixed?

I had to work around this and highlight the candidates in Completer::complete() instead.

In my testing selfinsert doesn't seem to work, it inserts one white-space character instead of an actual tab, changing it to insert makes it work perfectly.