repl-lang 1.1.1

Read-eval-print loop scaffolding: line editing, session state, and incremental input feed.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! The line editor, driven by a scripted sequence of keystrokes.
//!
//! A real host reads key events from a terminal library and maps them to
//! `Edit` commands; this example replays a fixed sequence instead, so it runs
//! anywhere and prints the same output every time. After each step it draws
//! the line the way a terminal would, with a caret under the cursor column —
//! note how the wide characters in `"界"` take two columns, and how the
//! combining accent in `"é"` never separates from its letter.
//!
//! ```text
//! cargo run --example line_editing
//! ```

use repl_lang::{Edit, Editor};
use unicode_lang::str_width;

/// One keystroke: a label for the transcript and what it does.
enum Key {
    Type(&'static str),
    Edit(&'static str, Edit),
    Enter,
}

const PROMPT: &str = "> ";

fn main() {
    let mut editor = Editor::with_history(100);
    // History restored from an earlier session.
    for saved in ["let width = 12", "width * 2"] {
        editor.add_history(saved);
    }

    let keys = [
        Key::Type("print hello"),
        Key::Edit("Ctrl-W  (kill word)", Edit::KillWordLeft),
        Key::Type("世界"),
        Key::Edit("Home", Edit::Home),
        Key::Edit("Alt-F   (word right)", Edit::WordRight),
        Key::Type("ln"),
        Key::Edit("End", Edit::End),
        Key::Edit("Backspace", Edit::Backspace),
        Key::Edit("Ctrl-Y  (yank)", Edit::Yank),
        Key::Enter,
        Key::Type("caf\u{0065}\u{0301}"),
        Key::Edit("←", Edit::Left),
        Key::Edit("←", Edit::Left),
        Key::Edit("Ctrl-K  (kill to end)", Edit::KillToEnd),
        Key::Edit("Ctrl-U  (kill to start)", Edit::KillToStart),
        Key::Edit("↑", Edit::HistoryPrev),
        Key::Edit("↑", Edit::HistoryPrev),
        Key::Edit("↑", Edit::HistoryPrev),
        Key::Edit("↓", Edit::HistoryNext),
        Key::Type(" + 1"),
        Key::Enter,
    ];

    for key in &keys {
        let (label, changed) = match key {
            Key::Type(text) => (format!("type {text:?}"), editor.insert(text)),
            Key::Edit(label, edit) => ((*label).to_owned(), editor.apply(*edit)),
            Key::Enter => {
                let line = editor.submit().to_owned();
                println!("{} submitted {line:?}\n", pad("Enter"));
                continue;
            }
        };
        let note = if changed { "" } else { "  (no change)" };
        println!("{} {PROMPT}{}{note}", pad(&label), editor.line());
        println!(
            "{} {}^",
            pad(""),
            " ".repeat(PROMPT.len() + editor.column())
        );
    }

    println!("History, oldest first:");
    for (i, line) in editor.history().enumerate() {
        println!("  {:>2}  {line}", i + 1);
    }
}

/// Pads `label` to a fixed number of terminal columns. `format!("{:<26}")`
/// pads by `char` count, which misaligns labels containing wide characters.
fn pad(label: &str) -> String {
    let fill = 26_usize.saturating_sub(str_width(label));
    format!("{label}{}", " ".repeat(fill))
}