lios-bar 0.1.1

A native GTK4/VTE sidebar workspace for navigating live Lios terminal sessions.
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

const LARGE_PASTE_BYTES: usize = 4096;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Assessment {
    pub(crate) line_breaks: usize,
    pub(crate) lines: usize,
    pub(crate) characters: usize,
    pub(crate) bytes: usize,
    pub(crate) controls: usize,
    pub(crate) unusually_large: bool,
}

impl Assessment {
    pub(crate) fn requires_confirmation(self) -> bool {
        self.line_breaks > 0 || self.controls > 0 || self.unusually_large
    }

    pub(crate) fn detail(self) -> String {
        let mut reasons = Vec::new();
        if self.line_breaks > 0 {
            reasons.push(format!("{} line break(s)", self.line_breaks));
        }
        if self.controls > 0 {
            reasons.push(format!("{} unsafe control character(s)", self.controls));
        }
        if self.unusually_large {
            reasons.push(format!("{} UTF-8 bytes", self.bytes));
        }
        format!(
            "This paste contains {}. Total: {} line(s), {} character(s), {} byte(s). The clipboard contents are intentionally hidden.",
            reasons.join(", "),
            self.lines,
            self.characters,
            self.bytes
        )
    }
}

pub(crate) fn classify(text: &str) -> Assessment {
    let mut line_breaks = 0;
    let mut lines = usize::from(!text.is_empty());
    let mut controls = 0;
    let mut characters = 0;
    let mut previous_cr = false;

    for character in text.chars() {
        characters += 1;
        match character {
            '\r' => {
                line_breaks += 1;
                lines += 1;
                previous_cr = true;
            }
            '\n' => {
                if !previous_cr {
                    line_breaks += 1;
                    lines += 1;
                }
                previous_cr = false;
            }
            '\t' => previous_cr = false,
            character if character.is_control() => {
                controls += 1;
                previous_cr = false;
            }
            _ => previous_cr = false,
        }
    }

    Assessment {
        line_breaks,
        lines,
        characters,
        bytes: text.len(),
        controls,
        unusually_large: text.len() > LARGE_PASTE_BYTES,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn single_line_and_tab_are_safe() {
        assert!(!classify("printf 'ok'\t").requires_confirmation());
    }

    #[test]
    fn newline_control_and_large_text_are_guarded() {
        assert!(classify("one\ntwo").requires_confirmation());
        assert!(classify("safe\u{1b}unsafe").requires_confirmation());
        assert!(classify(&"x".repeat(4097)).requires_confirmation());
    }

    #[test]
    fn detail_never_contains_clipboard_payload() {
        let secret = "secret-one\nsecret-two";
        let detail = classify(secret).detail();
        assert!(!detail.contains("secret-one"));
        assert!(detail.contains("line break"));
    }
}