xplit 0.5.0

A minimal terminal splitter with no prefix key and no configuration
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
116
117
118
119
120
121
122

// Author: David M. Anderson
// Built with AI assistance (Claude, Anthropic)

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct Point {
    pub line: usize,
    pub col: u16,
}

#[derive(Debug, Clone, Copy)]
pub struct Selection {
    pub pane: usize,
    pub alternate: bool,
    pub output: u64,
    anchor: Point,
    head: Point,
}

impl Selection {
    pub fn new(pane: usize, at: Point, alternate: bool, output: u64) -> Selection {
        Selection {
            pane,
            alternate,
            output,
            anchor: at,
            head: at,
        }
    }

    pub fn extend(&mut self, to: Point) {
        self.head = to;
    }

    pub fn is_empty(&self) -> bool {
        self.anchor == self.head
    }

    pub fn contains(&self, point: Point) -> bool {
        let (start, end) = self.bounds();
        start <= point && point <= end
    }

    pub fn text(
        &self,
        cols: u16,
        line_text: impl Fn(usize, u16, u16) -> Option<(String, bool)>,
    ) -> String {
        let (start, end) = self.bounds();
        let mut text = String::new();
        for line in start.line..=end.line {
            let from = if line == start.line { start.col } else { 0 };
            let to = if line == end.line { end.col + 1 } else { cols };
            let Some((content, wrapped)) = line_text(line, from, to) else {
                break;
            };
            if wrapped && line != end.line {
                text.push_str(&content);
            } else {
                text.push_str(content.trim_end());
                if line != end.line {
                    text.push('\n');
                }
            }
        }
        text
    }

    fn bounds(&self) -> (Point, Point) {
        (self.anchor.min(self.head), self.anchor.max(self.head))
    }
}

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

    fn point(line: usize, col: u16) -> Point {
        Point { line, col }
    }

    fn selection(from: Point, to: Point) -> Selection {
        let mut selection = Selection::new(0, from, false, 0);
        selection.extend(to);
        selection
    }

    #[test]
    fn contains_runs_in_reading_order() {
        let selection = selection(point(3, 5), point(1, 2));
        assert!(selection.contains(point(1, 2)));
        assert!(selection.contains(point(2, 0)));
        assert!(selection.contains(point(2, 79)));
        assert!(selection.contains(point(3, 5)));
        assert!(!selection.contains(point(1, 1)));
        assert!(!selection.contains(point(3, 6)));
    }

    #[test]
    fn text_joins_wrapped_lines_and_trims_padding() {
        let lines = [
            ("abcdefghij", true),
            ("klm", false),
            ("short     ", false),
            ("last", false),
        ];
        let read = |line: usize, start: u16, end: u16| {
            let (text, wrapped) = lines.get(line)?;
            let end = usize::from(end).min(text.len());
            let start = usize::from(start).min(end);
            Some((text[start..end].to_string(), *wrapped))
        };
        let selection = selection(point(0, 2), point(3, 1));
        assert_eq!(selection.text(10, read), "cdefghijklm\nshort\nla");
    }

    #[test]
    fn text_stops_where_the_lines_run_out() {
        let read = |line: usize, _: u16, _: u16| (line < 2).then(|| (format!("line{line}"), false));
        let selection = selection(point(0, 0), point(5, 3));
        assert_eq!(selection.text(10, read), "line0\nline1\n");
    }
}