guise/input/

edit.rs

//! Pure single-line text-editing model: a string plus a char-index cursor,
//! with the operations a text field needs. No UI — fully unit-testable; the
//! `TextInput` entity drives it from key events and renders from `split`.

/// How many undo steps a field remembers.
const UNDO_DEPTH: usize = 128;

/// …and how much text those steps may hold between them, in chars.
///
/// A step is a whole copy of the buffer, which is nothing for a one-line field
/// and a great deal for a `TextArea` holding a document: 128 steps of a 200 KB
/// buffer is 100 MB of `Vec<char>`. Bounding the depth alone leaves that hole,
/// so history is bounded by what it *retains* as well, and the oldest steps
/// are dropped first. A quarter-million chars is far more history than anyone
/// undoes through, and it costs a megabyte at worst.
const UNDO_CHARS: usize = 256 * 1024;

/// What the last mutation was, so a run of the same kind coalesces into one
/// undo step instead of one step per keystroke.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum EditKind {
    Insert,
    Delete,
}

/// A restorable point in the edit history.
#[derive(Debug, Clone)]
struct Snapshot {
    chars: Vec<char>,
    cursor: usize,
    anchor: Option<usize>,
}

/// An editable line of text with a cursor and an optional selection.
#[derive(Debug, Clone, Default)]
pub struct TextEdit {
    chars: Vec<char>,
    /// Cursor position as a char index in `0..=chars.len()`.
    cursor: usize,
    /// Selection anchor; a selection spans `anchor..cursor` in either order.
    /// `None` means no selection.
    anchor: Option<usize>,
    undos: Vec<Snapshot>,
    redos: Vec<Snapshot>,
    /// The kind of the mutation that produced the newest undo entry, so the
    /// next one of the same kind can fold into it.
    run: Option<EditKind>,
}

impl TextEdit {
    /// Start editing `text` with the cursor at the end.
    pub fn new(text: &str) -> Self {
        let chars: Vec<char> = text.chars().collect();
        let cursor = chars.len();
        Self {
            chars,
            cursor,
            anchor: None,
            undos: Vec::new(),
            redos: Vec::new(),
            run: None,
        }
    }

    pub fn text(&self) -> String {
        self.chars.iter().collect()
    }

    /// The buffer itself. Callers that only need to measure or slice the text
    /// use this instead of [`text`](Self::text), which allocates a fresh
    /// `String` every call — and the platform's input handler asks several
    /// times per keystroke.
    pub fn chars(&self) -> &[char] {
        &self.chars
    }

    pub fn is_empty(&self) -> bool {
        self.chars.is_empty()
    }

    /// Length in chars, which is also the last valid cursor position.
    pub fn len(&self) -> usize {
        self.chars.len()
    }

    /// The cursor as a char index.
    pub fn cursor(&self) -> usize {
        self.cursor
    }

    /// Move the cursor, dropping any selection. Out-of-range values clamp.
    pub fn set_cursor(&mut self, index: usize) {
        self.cursor = index.min(self.chars.len());
        self.anchor = None;
        self.run = None;
    }

    /// Select `start..end` and leave the cursor at `end`, so a following
    /// Shift+Arrow extends from the edge the user last moved.
    pub fn set_selection(&mut self, start: usize, end: usize) {
        let n = self.chars.len();
        self.anchor = Some(start.min(n));
        self.cursor = end.min(n);
        self.run = None;
    }

    /// Move the selection's free edge to `index`, opening a selection anchored
    /// at the cursor if there isn't one. This is Shift+click and mouse drag.
    pub fn extend_to(&mut self, index: usize) {
        if self.anchor.is_none() {
            self.anchor = Some(self.cursor);
        }
        self.cursor = index.min(self.chars.len());
        self.run = None;
    }

    /// Replace everything, as a programmatic set: the history is dropped
    /// because the old text is no longer something the user can undo back to.
    /// That also releases whatever the history was holding.
    pub fn set_text(&mut self, text: &str) {
        *self = TextEdit::new(text);
    }

    /// Byte offset into [`text`](Self::text) for a char index. Shaped-line
    /// geometry is addressed in bytes, the edit model in chars.
    pub fn byte_of(&self, index: usize) -> usize {
        self.chars[..index.min(self.chars.len())]
            .iter()
            .map(|c| c.len_utf8())
            .sum()
    }

    /// Char index for a byte offset, rounding up to the next char boundary.
    pub fn char_of(&self, byte: usize) -> usize {
        let mut at = 0;
        for (index, c) in self.chars.iter().enumerate() {
            if at >= byte {
                return index;
            }
            at += c.len_utf8();
        }
        self.chars.len()
    }

    /// The word surrounding `index` as `(start, end)` char indices — what a
    /// double-click selects. A click in whitespace takes the whitespace run.
    pub fn word_at(&self, index: usize) -> (usize, usize) {
        let n = self.chars.len();
        if n == 0 {
            return (0, 0);
        }
        // A click at the very end, or just past a word, belongs to the char
        // before it — the same way a browser resolves the boundary case.
        let probe = index.min(n - 1);
        let wordish = is_word(self.chars[probe]);
        let mut start = probe;
        while start > 0 && is_word(self.chars[start - 1]) == wordish {
            start -= 1;
        }
        let mut end = probe;
        while end < n && is_word(self.chars[end]) == wordish {
            end += 1;
        }
        (start, end)
    }

    /// Undo the last edit. Returns whether there was one.
    pub fn undo(&mut self) -> bool {
        let Some(previous) = self.undos.pop() else {
            return false;
        };
        self.redos.push(self.snapshot());
        self.restore(previous);
        true
    }

    /// Redo the last undone edit. Returns whether there was one.
    pub fn redo(&mut self) -> bool {
        let Some(next) = self.redos.pop() else {
            return false;
        };
        self.undos.push(self.snapshot());
        self.restore(next);
        true
    }

    fn snapshot(&self) -> Snapshot {
        Snapshot {
            chars: self.chars.clone(),
            cursor: self.cursor,
            anchor: self.anchor,
        }
    }

    fn restore(&mut self, snapshot: Snapshot) {
        self.chars = snapshot.chars;
        self.cursor = snapshot.cursor.min(self.chars.len());
        self.anchor = snapshot.anchor.map(|a| a.min(self.chars.len()));
        self.run = None;
    }

    /// Remember the pre-edit state, unless this continues a run of the same
    /// kind — typing a word is one undo step, not one per letter.
    fn record(&mut self, kind: EditKind) {
        self.redos.clear();
        if self.run == Some(kind) {
            return;
        }
        self.undos.push(self.snapshot());
        // Oldest first: the step you are least likely to reach for is the one
        // furthest back.
        while self.undos.len() > UNDO_DEPTH
            || (self.history_chars() > UNDO_CHARS && self.undos.len() > 1)
        {
            self.undos.remove(0);
        }
        self.run = Some(kind);
    }

    /// Chars held by the undo history. Summed on demand rather than tracked
    /// incrementally: the stacks are at most [`UNDO_DEPTH`] deep and this is
    /// only asked while trimming, which is nowhere near a hot path.
    pub(crate) fn history_chars(&self) -> usize {
        self.undos
            .iter()
            .chain(&self.redos)
            .map(|snapshot| snapshot.chars.len())
            .sum()
    }

    /// End the current coalescing run, so the next edit starts a fresh undo
    /// step. Callers use this at word boundaries and on paste.
    pub fn break_undo(&mut self) {
        self.run = None;
    }

    /// The selected span `(start, end)` as char indices, or `None` if the
    /// selection is empty/collapsed.
    pub fn selection(&self) -> Option<(usize, usize)> {
        let a = self.anchor?;
        (a != self.cursor).then(|| (a.min(self.cursor), a.max(self.cursor)))
    }

    pub fn has_selection(&self) -> bool {
        self.selection().is_some()
    }

    /// The selected text, or `None` when nothing is selected.
    pub fn selected_text(&self) -> Option<String> {
        let (s, e) = self.selection()?;
        Some(self.chars[s..e].iter().collect())
    }

    /// Select the whole line.
    pub fn select_all(&mut self) {
        if self.chars.is_empty() {
            self.anchor = None;
            return;
        }
        self.anchor = Some(0);
        self.cursor = self.chars.len();
    }

    /// Drop any selection, keeping the cursor put.
    pub fn clear_selection(&mut self) {
        self.anchor = None;
    }

    pub fn collapse_selection_start(&mut self) -> bool {
        let Some((start, _)) = self.selection() else {
            return false;
        };
        self.cursor = start;
        self.anchor = None;
        true
    }

    pub fn collapse_selection_end(&mut self) -> bool {
        let Some((_, end)) = self.selection() else {
            return false;
        };
        self.cursor = end;
        self.anchor = None;
        true
    }

    /// Delete the selected text (if any), leaving the cursor at its start.
    /// Returns whether anything was removed.
    pub fn delete_selection(&mut self) -> bool {
        if self.selection().is_none() {
            return false;
        }
        self.record(EditKind::Delete);
        self.take_selection()
    }

    /// [`delete_selection`](Self::delete_selection) without touching the undo
    /// history, for the mutators that have already recorded their own step.
    fn take_selection(&mut self) -> bool {
        let Some((s, e)) = self.selection() else {
            return false;
        };
        self.chars.drain(s..e);
        self.cursor = s;
        self.anchor = None;
        true
    }

    /// Prepare for a cursor move: with `extend` (Shift held) anchor a selection
    /// at the current cursor if one isn't already open; otherwise drop it.
    pub fn pre_move(&mut self, extend: bool) {
        if extend {
            if self.anchor.is_none() {
                self.anchor = Some(self.cursor);
            }
        } else {
            self.anchor = None;
        }
    }

    /// The text split around the selection: `(before, selected, after)`, or
    /// `None` when nothing is selected.
    pub fn split_selection(&self) -> Option<(String, String, String)> {
        let (s, e) = self.selection()?;
        Some((
            self.chars[..s].iter().collect(),
            self.chars[s..e].iter().collect(),
            self.chars[e..].iter().collect(),
        ))
    }

    /// Insert `s` at the cursor, replacing any selection, advancing past it.
    pub fn insert(&mut self, s: &str) {
        if s.is_empty() && !self.has_selection() {
            return;
        }
        self.record(EditKind::Insert);
        self.take_selection();
        // `splice` shifts the tail once. Inserting char by char shifts it per
        // character, which turns a large paste near the start of a long buffer
        // into quadratic work on the UI thread.
        let at = self.cursor;
        self.chars.splice(at..at, s.chars());
        self.cursor += s.chars().count();
        // Typing a word is one undo step; the space after it ends that step so
        // undo walks back word by word rather than wiping the whole line.
        if s.chars().any(|c| c.is_whitespace()) {
            self.run = None;
        }
    }

    /// Replace the char range `range` with `s`, leaving the cursor after it.
    /// This is the entry point the platform's text-input handler drives, so it
    /// takes an explicit range rather than using the selection.
    pub fn replace_range(&mut self, range: std::ops::Range<usize>, s: &str) {
        let n = self.chars.len();
        let start = range.start.min(n);
        let end = range.end.clamp(start, n);
        self.record(EditKind::Insert);
        self.chars.splice(start..end, s.chars());
        self.cursor = start + s.chars().count();
        self.anchor = None;
        if s.chars().any(|c| c.is_whitespace()) {
            self.run = None;
        }
    }

    /// Delete the selection, or the char before the cursor. Returns whether
    /// anything changed.
    pub fn backspace(&mut self) -> bool {
        if self.has_selection() {
            return self.delete_selection();
        }
        if self.cursor == 0 {
            return false;
        }
        self.record(EditKind::Delete);
        self.cursor -= 1;
        self.chars.remove(self.cursor);
        true
    }

    /// Delete the selection, or the char at the cursor. Returns whether anything
    /// changed.
    pub fn delete(&mut self) -> bool {
        if self.has_selection() {
            return self.delete_selection();
        }
        if self.cursor >= self.chars.len() {
            return false;
        }
        self.record(EditKind::Delete);
        self.chars.remove(self.cursor);
        true
    }

    pub fn left(&mut self) {
        self.cursor = self.cursor.saturating_sub(1);
    }

    pub fn right(&mut self) {
        if self.cursor < self.chars.len() {
            self.cursor += 1;
        }
    }

    pub fn home(&mut self) {
        self.cursor = 0;
    }

    pub fn end(&mut self) {
        self.cursor = self.chars.len();
    }

    pub fn line_home(&mut self) {
        while self.cursor > 0 && self.chars[self.cursor - 1] != '\n' {
            self.cursor -= 1;
        }
    }

    pub fn line_end(&mut self) {
        while self.cursor < self.chars.len() && self.chars[self.cursor] != '\n' {
            self.cursor += 1;
        }
    }

    /// Move left to the start of the previous word (Option+Left on macOS).
    pub fn word_left(&mut self) {
        while self.cursor > 0 && !is_word(self.chars[self.cursor - 1]) {
            self.cursor -= 1;
        }
        while self.cursor > 0 && is_word(self.chars[self.cursor - 1]) {
            self.cursor -= 1;
        }
    }

    /// Move right past the end of the next word (Option+Right on macOS).
    pub fn word_right(&mut self) {
        let n = self.chars.len();
        while self.cursor < n && !is_word(self.chars[self.cursor]) {
            self.cursor += 1;
        }
        while self.cursor < n && is_word(self.chars[self.cursor]) {
            self.cursor += 1;
        }
    }

    /// Delete the word before the cursor (Option+Backspace). Returns whether
    /// anything changed.
    pub fn delete_word_back(&mut self) -> bool {
        if self.has_selection() {
            return self.delete_selection();
        }
        let end = self.cursor;
        self.word_left();
        if self.cursor < end {
            self.record(EditKind::Delete);
            self.chars.drain(self.cursor..end);
            self.run = None;
            true
        } else {
            false
        }
    }

    /// Delete the word after the cursor (Option+Delete). Returns whether
    /// anything changed.
    pub fn delete_word_forward(&mut self) -> bool {
        if self.has_selection() {
            return self.delete_selection();
        }
        let start = self.cursor;
        let n = self.chars.len();
        let mut end = self.cursor;
        while end < n && !is_word(self.chars[end]) {
            end += 1;
        }
        while end < n && is_word(self.chars[end]) {
            end += 1;
        }
        if end > start {
            self.record(EditKind::Delete);
            self.chars.drain(start..end);
            self.run = None;
            true
        } else {
            false
        }
    }

    /// Delete from the cursor to the line start (Cmd+Backspace). Returns
    /// whether anything changed.
    pub fn delete_to_start(&mut self) -> bool {
        if self.has_selection() {
            return self.delete_selection();
        }
        if self.cursor == 0 {
            return false;
        }
        self.record(EditKind::Delete);
        self.chars.drain(0..self.cursor);
        self.cursor = 0;
        self.run = None;
        true
    }

    /// Delete from the cursor to the line end (Cmd+Delete / Ctrl+K). Returns
    /// whether anything changed.
    pub fn delete_to_end(&mut self) -> bool {
        if self.has_selection() {
            return self.delete_selection();
        }
        if self.cursor >= self.chars.len() {
            return false;
        }
        self.record(EditKind::Delete);
        self.chars.truncate(self.cursor);
        self.run = None;
        true
    }

    /// The text before and after the cursor, for rendering a caret between.
    pub fn split(&self) -> (String, String) {
        (
            self.chars[..self.cursor].iter().collect(),
            self.chars[self.cursor..].iter().collect(),
        )
    }

    /// Move the cursor up one line, keeping the column where possible. Multiline
    /// only (single-line text has nowhere to go).
    pub fn up(&mut self) {
        self.vmove(-1);
    }

    /// Move the cursor down one line, keeping the column where possible.
    pub fn down(&mut self) {
        self.vmove(1);
    }

    /// (line, column) of the cursor, counting `\n`-separated lines.
    fn line_col(&self) -> (usize, usize) {
        let mut line = 0;
        let mut col = 0;
        for &c in &self.chars[..self.cursor] {
            if c == '\n' {
                line += 1;
                col = 0;
            } else {
                col += 1;
            }
        }
        (line, col)
    }

    /// (start char index, length excluding newline) for each line.
    fn line_bounds(&self) -> Vec<(usize, usize)> {
        let mut out = Vec::new();
        let mut start = 0;
        let mut len = 0;
        for (i, &c) in self.chars.iter().enumerate() {
            if c == '\n' {
                out.push((start, len));
                start = i + 1;
                len = 0;
            } else {
                len += 1;
            }
        }
        out.push((start, len));
        out
    }

    fn vmove(&mut self, dir: isize) {
        let (line, col) = self.line_col();
        let bounds = self.line_bounds();
        let target = line as isize + dir;
        if target < 0 || target as usize >= bounds.len() {
            return;
        }
        let (start, len) = bounds[target as usize];
        self.cursor = start + col.min(len);
    }
}

/// Word characters for word-wise navigation/deletion.
fn is_word(c: char) -> bool {
    c.is_alphanumeric() || c == '_'
}

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

    #[test]
    fn new_places_cursor_at_end() {
        let e = TextEdit::new("abc");
        assert_eq!(e.split(), ("abc".into(), "".into()));
    }

    #[test]
    fn insert_at_cursor() {
        let mut e = TextEdit::new("ac");
        e.left();
        e.insert("b");
        assert_eq!(e.text(), "abc");
        assert_eq!(e.split(), ("ab".into(), "c".into()));
    }

    #[test]
    fn backspace_and_delete() {
        let mut e = TextEdit::new("abc");
        assert!(e.backspace());
        assert_eq!(e.text(), "ab");
        e.home();
        assert!(e.delete());
        assert_eq!(e.text(), "b");
        e.home();
        assert!(!e.backspace());
        e.end();
        assert!(!e.delete());
    }

    #[test]
    fn handles_unicode() {
        let mut e = TextEdit::new("café");
        assert!(e.backspace());
        assert_eq!(e.text(), "caf");
        e.insert("é");
        assert_eq!(e.text(), "café");
    }

    #[test]
    fn vertical_movement_keeps_column() {
        // Two lines: "hello" / "hi". Cursor starts at end ("hi").
        let mut e = TextEdit::new("hello\nhi");
        // Column 2 on line 1.
        e.up();
        // Same column (2) on line 0 → between "he" and "llo".
        assert_eq!(e.split().0, "he");
        e.down();
        // Back to line 1; column clamped to its length (2) → end.
        assert_eq!(e.split(), ("hello\nhi".into(), "".into()));
    }

    #[test]
    fn vertical_movement_stops_at_edges() {
        let mut e = TextEdit::new("a\nb");
        e.home(); // line 1 has only the final char; home goes to absolute start
        e.up(); // already on first line, no-op
        assert_eq!(e.split().0, "");
    }

    #[test]
    fn word_navigation() {
        let mut e = TextEdit::new("foo bar baz");
        e.word_left();
        assert_eq!(e.split(), ("foo bar ".into(), "baz".into()));
        e.word_left();
        assert_eq!(e.split(), ("foo ".into(), "bar baz".into()));
        e.word_right();
        assert_eq!(e.split(), ("foo bar".into(), " baz".into()));
    }

    #[test]
    fn delete_word_back_and_forward() {
        let mut e = TextEdit::new("foo bar baz");
        assert!(e.delete_word_back());
        assert_eq!(e.text(), "foo bar ");
        e.home();
        assert!(e.delete_word_forward());
        assert_eq!(e.text(), " bar ");
        // Nothing before the cursor at home: no-op.
        e.home();
        assert!(!e.delete_word_back());
    }

    #[test]
    fn select_all_then_type_replaces() {
        let mut e = TextEdit::new("hello");
        e.select_all();
        assert_eq!(e.selected_text().as_deref(), Some("hello"));
        e.insert("x");
        assert_eq!(e.text(), "x");
        assert!(!e.has_selection());
    }

    #[test]
    fn shift_arrow_extends_selection() {
        let mut e = TextEdit::new("abcd");
        e.pre_move(true);
        e.left(); // select "d"
        e.pre_move(true);
        e.left(); // select "cd"
        assert_eq!(e.selected_text().as_deref(), Some("cd"));
        let (before, sel, after) = e.split_selection().unwrap();
        assert_eq!(
            (before.as_str(), sel.as_str(), after.as_str()),
            ("ab", "cd", "")
        );
    }

    #[test]
    fn plain_move_clears_selection() {
        let mut e = TextEdit::new("abcd");
        e.select_all();
        e.pre_move(false);
        e.left();
        assert!(!e.has_selection());
    }

    #[test]
    fn backspace_deletes_selection() {
        let mut e = TextEdit::new("abcd");
        e.select_all();
        assert!(e.backspace());
        assert_eq!(e.text(), "");
    }

    #[test]
    fn modified_deletes_replace_the_selection() {
        for delete in [
            TextEdit::delete_word_back as fn(&mut TextEdit) -> bool,
            TextEdit::delete_word_forward,
            TextEdit::delete_to_start,
            TextEdit::delete_to_end,
        ] {
            let mut edit = TextEdit::new("abcd");
            edit.select_all();
            assert!(delete(&mut edit));
            assert_eq!(edit.text(), "");
        }
    }

    #[test]
    fn selection_collapses_to_the_requested_edge() {
        let mut edit = TextEdit::new("abcd");
        edit.select_all();
        assert!(edit.collapse_selection_start());
        assert_eq!(edit.split().0, "");
        edit.select_all();
        assert!(edit.collapse_selection_end());
        assert_eq!(edit.split().0, "abcd");
    }

    #[test]
    fn delete_to_line_edges() {
        let mut e = TextEdit::new("hello world");
        e.home();
        e.right();
        e.right();
        assert!(e.delete_to_start());
        assert_eq!(e.text(), "llo world");
        assert!(e.delete_to_end());
        assert_eq!(e.text(), "");
        assert!(!e.delete_to_end());
    }

    #[test]
    fn line_edges_stay_on_the_current_line() {
        let mut e = TextEdit::new("one\ntwo\nthree");
        e.up();
        e.line_home();
        assert_eq!(e.split().0, "one\n");
        e.line_end();
        assert_eq!(e.split().0, "one\ntwo");
    }

    /// An undo step is a whole copy of the buffer, so a big document must not
    /// be able to turn a bounded step count into unbounded memory.
    #[test]
    fn undo_history_is_bounded_by_the_text_it_retains() {
        let big = "x".repeat(64 * 1024);
        let mut edit = TextEdit::new(&big);
        // Each edit is its own step (the deletes break the coalescing run).
        for i in 0..64 {
            edit.insert(&format!("{i} "));
            edit.backspace();
        }
        assert!(
            edit.history_chars() <= UNDO_CHARS + big.chars().count(),
            "history held {} chars",
            edit.history_chars()
        );
        // The recent past still works even though the distant past was dropped.
        assert!(edit.undo());
        assert!(edit.undo());
    }

    #[test]
    fn undo_accounting_survives_a_round_trip() {
        let mut edit = TextEdit::new("");
        edit.insert("alpha ");
        edit.insert("beta");
        let before = edit.history_chars();
        assert!(edit.undo());
        assert!(edit.redo());
        assert_eq!(edit.history_chars(), before);
        assert_eq!(edit.text(), "alpha beta");
        // A fresh edit discards the redo stack and its accounting with it.
        edit.insert("!");
        assert!(edit.history_chars() > 0);
    }

    #[test]
    fn set_text_releases_the_history() {
        let mut edit = TextEdit::new(&"y".repeat(4096));
        edit.insert("a");
        edit.backspace();
        assert!(edit.history_chars() > 0);
        edit.set_text("small");
        assert_eq!(edit.history_chars(), 0);
        assert!(!edit.undo());
    }

    #[test]
    fn chars_matches_text_without_allocating() {
        let edit = TextEdit::new("caf\u{e9} \u{1f600}");
        assert_eq!(edit.chars().iter().collect::<String>(), edit.text());
        assert_eq!(edit.chars().len(), edit.len());
    }
}