taba-cli 0.1.0

The Taba client command line.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! The keys: decodes the bytes the raw-mode terminal delivers (UTF-8 text and ANSI sequences
//! for arrows and the like).

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Key {
    Up,
    Down,
    Left,
    Right,
    Home,
    End,
    Delete,
    Backspace,
    Enter,
    Tab,
    BackTab,
    Esc,
    Char(char),
    /// Ctrl with a lowercase letter (`Ctrl('s')`).
    Ctrl(char),
}

/// Decodes everything that arrived in one read. An unknown sequence is skipped whole.
pub fn decode(bytes: &[u8]) -> Vec<Key> {
    let mut keys = Vec::new();
    let mut i = 0;
    while i < bytes.len() {
        let b = bytes[i];
        match b {
            0x1b => {
                if i + 1 >= bytes.len() {
                    keys.push(Key::Esc);
                    i += 1;
                    continue;
                }
                match bytes[i + 1] {
                    b'[' | b'O' => {
                        // CSI / SS3: parameters and then the final byte (0x40..=0x7e).
                        let mut j = i + 2;
                        while j < bytes.len() && !(0x40..=0x7e).contains(&bytes[j]) {
                            j += 1;
                        }
                        let params = &bytes[i + 2..j.min(bytes.len())];
                        if let Some(&final_byte) = bytes.get(j) {
                            if let Some(key) = csi_key(params, final_byte) {
                                keys.push(key);
                            }
                        }
                        i = j + 1;
                    }
                    // Alt+key and others: ignores the ESC and processes the key.
                    _ => i += 1,
                }
            }
            0x0d | 0x0a => {
                keys.push(Key::Enter);
                i += 1;
            }
            0x09 => {
                keys.push(Key::Tab);
                i += 1;
            }
            0x7f | 0x08 => {
                keys.push(Key::Backspace);
                i += 1;
            }
            0x01..=0x1a => {
                keys.push(Key::Ctrl((b - 1 + b'a') as char));
                i += 1;
            }
            0x00 | 0x1c..=0x1f => i += 1,
            _ => {
                // A UTF-8 character (1 to 4 bytes).
                let len = match b {
                    0x00..=0x7f => 1,
                    0xc0..=0xdf => 2,
                    0xe0..=0xef => 3,
                    0xf0..=0xf7 => 4,
                    _ => 1,
                };
                let end = (i + len).min(bytes.len());
                if let Some(c) = std::str::from_utf8(&bytes[i..end])
                    .ok()
                    .and_then(|s| s.chars().next())
                {
                    keys.push(Key::Char(c));
                }
                i = end;
            }
        }
    }
    keys
}

fn csi_key(params: &[u8], final_byte: u8) -> Option<Key> {
    match final_byte {
        b'A' => Some(Key::Up),
        b'B' => Some(Key::Down),
        b'C' => Some(Key::Right),
        b'D' => Some(Key::Left),
        b'H' => Some(Key::Home),
        b'F' => Some(Key::End),
        b'Z' => Some(Key::BackTab),
        b'~' => match params {
            b"1" | b"7" => Some(Key::Home),
            b"4" | b"8" => Some(Key::End),
            b"3" => Some(Key::Delete),
            _ => None,
        },
        _ => None,
    }
}

#[cfg(test)]
mod tests;