cranpose_foundation/text/

buffer.rs

use smallvec::SmallVec;
use unicode_segmentation::GraphemeCursor;

use super::{TextFieldValue, TextRange};

/// A mutable text buffer that can be edited.
///
/// This provides methods for changing text content:
/// - [`replace`](Self::replace) - Replace a range with new text
/// - [`append`](Self::append) - Add text at the end
/// - [`insert`](Self::insert) - Insert text at cursor position
/// - [`delete`](Self::delete) - Delete a range of text
///
/// And for manipulating cursor/selection:
/// - [`place_cursor_at_end`](Self::place_cursor_at_end)
/// - [`place_cursor_before_char`](Self::place_cursor_before_char)
/// - [`move_cursor_left`](Self::move_cursor_left)
/// - [`select_all`](Self::select_all)
///
/// Keyboard editing steps over whole user-perceived characters, Unicode's
/// extended grapheme clusters: a flag, an emoji joined with zero-width
/// joiners, a letter with its combining marks. Offsets are UTF-8 bytes.
///
/// # Example
///
/// ```
/// use cranpose_foundation::text::{TextFieldBuffer, TextRange};
///
/// let mut buffer = TextFieldBuffer::new("Hello");
/// buffer.place_cursor_at_end();
/// buffer.insert(", World!");
/// assert_eq!(buffer.text(), "Hello, World!");
/// ```
#[derive(Debug, Clone)]
pub struct TextFieldBuffer {
    text: String,
    selection: TextRange,
    composition: Option<TextRange>,
    has_changes: bool,
}

impl TextFieldBuffer {
    /// Creates a new buffer with the given initial text.
    /// Cursor is placed at the end of the text.
    pub fn new(initial_text: impl Into<String>) -> Self {
        let text: String = initial_text.into();
        let len = text.len();
        Self {
            text,
            selection: TextRange::cursor(len),
            composition: None,
            has_changes: false,
        }
    }

    /// Creates a buffer with text and specified selection.
    pub fn with_selection(text: impl Into<String>, selection: TextRange) -> Self {
        let text: String = text.into();
        let selection = selection.coerce_in(text.len());
        Self {
            text,
            selection,
            composition: None,
            has_changes: false,
        }
    }

    /// Returns the current text content.
    pub fn text(&self) -> &str {
        &self.text
    }

    /// Returns the length of the text in bytes.
    pub fn len(&self) -> usize {
        self.text.len()
    }

    /// Returns true if the buffer is empty.
    pub fn is_empty(&self) -> bool {
        self.text.is_empty()
    }

    /// Returns the current selection range.
    pub fn selection(&self) -> TextRange {
        self.selection
    }

    /// Returns the current composition (IME) range, if any.
    pub fn composition(&self) -> Option<TextRange> {
        self.composition
    }

    /// Returns true if there's a non-collapsed selection.
    pub fn has_selection(&self) -> bool {
        !self.selection.collapsed()
    }

    /// Returns true if any changes have been made.
    pub fn has_changes(&self) -> bool {
        self.has_changes
    }

    /// Replaces text in the given range with new text.
    ///
    /// The selection is adjusted based on the replacement:
    /// - If replacing before selection, selection shifts
    /// - If replacing within selection, cursor moves to end of replacement
    pub fn replace(&mut self, range: TextRange, replacement: &str) {
        let min = range.min().min(self.text.len());
        let max = range.max().min(self.text.len());

        self.text.replace_range(min..max, replacement);

        let new_end = min + replacement.len();
        self.selection = TextRange::cursor(new_end);

        self.composition = None;
        self.has_changes = true;
    }

    /// Inserts text at the current cursor position (or replaces selection).
    pub fn insert(&mut self, text: &str) {
        if self.has_selection() {
            self.replace(self.selection, text);
        } else {
            let pos = self.selection.start.min(self.text.len());
            self.text.insert_str(pos, text);
            self.selection = TextRange::cursor(pos + text.len());
            self.composition = None;
            self.has_changes = true;
        }
    }

    /// Appends text at the end of the buffer.
    pub fn append(&mut self, text: &str) {
        self.text.push_str(text);
        self.has_changes = true;
    }

    /// Deletes text in the given range.
    pub fn delete(&mut self, range: TextRange) {
        self.replace(range, "");
    }

    /// Deletes the selection, or the character before the cursor (backspace).
    pub fn delete_before_cursor(&mut self) {
        if self.has_selection() {
            self.delete(self.selection);
        } else if self.selection.start > 0 {
            let pos = self.selection.start;
            let prev_pos = self.prev_grapheme_boundary(pos);
            self.delete(TextRange::new(prev_pos, pos));
        }
    }

    /// Deletes the selection, or the character after the cursor (delete key).
    pub fn delete_after_cursor(&mut self) {
        if self.has_selection() {
            self.delete(self.selection);
        } else if self.selection.start < self.text.len() {
            let pos = self.selection.start;
            let next_pos = self.next_grapheme_boundary(pos);
            self.delete(TextRange::new(pos, next_pos));
        }
    }

    /// Deletes text surrounding the cursor or selection.
    ///
    /// `before_bytes` and `after_bytes` are byte counts in UTF-8.
    /// The deletion respects character boundaries and preserves any IME composition range.
    pub fn delete_surrounding(&mut self, before_bytes: usize, after_bytes: usize) {
        if self.text.is_empty() || (before_bytes == 0 && after_bytes == 0) {
            return;
        }

        let selection = self.selection;
        let mut start = selection.min().saturating_sub(before_bytes);
        let mut end = selection
            .max()
            .saturating_add(after_bytes)
            .min(self.text.len());

        start = self.text.floor_char_boundary(start);
        end = self.text.ceil_char_boundary(end);

        if start >= end {
            return;
        }

        // At most two ranges, either side of a composition, in text order.
        let mut ranges: SmallVec<[(usize, usize); 2]> = SmallVec::new();
        if let Some(comp) = self.composition {
            let comp_start = comp.min();
            let comp_end = comp.max();

            if end <= comp_start || start >= comp_end {
                ranges.push((start, end));
            } else {
                if start < comp_start {
                    ranges.push((start, comp_start));
                }
                if end > comp_end {
                    ranges.push((comp_end, end));
                }
            }
        } else {
            ranges.push((start, end));
        }

        if ranges.is_empty() {
            return;
        }

        for &(range_start, range_end) in ranges.iter().rev() {
            self.text.replace_range(range_start..range_end, "");
        }

        let removed_before = |pos: usize| -> usize {
            let mut removed = 0usize;
            for (range_start, range_end) in &ranges {
                if pos <= *range_start {
                    break;
                }
                let clamped_end = pos.min(*range_end);
                if clamped_end > *range_start {
                    removed += clamped_end - *range_start;
                }
            }
            removed
        };

        let cursor_pos = selection.min();
        let new_cursor = cursor_pos
            .saturating_sub(removed_before(cursor_pos))
            .min(self.text.len());

        self.selection = TextRange::cursor(new_cursor);
        self.composition = self.composition.map(|comp| {
            let comp_start = comp.min().saturating_sub(removed_before(comp.min()));
            let comp_end = comp.max().saturating_sub(removed_before(comp.max()));
            TextRange::new(comp_start, comp_end).coerce_in(self.text.len())
        });
        self.has_changes = true;
    }

    /// Clears all text.
    pub fn clear(&mut self) {
        self.text.clear();
        self.selection = TextRange::zero();
        self.composition = None;
        self.has_changes = true;
    }

    /// Places the cursor at the end of the text.
    pub fn place_cursor_at_end(&mut self) {
        self.selection = TextRange::cursor(self.text.len());
    }

    /// Places the cursor at the start of the text.
    pub fn place_cursor_at_start(&mut self) {
        self.selection = TextRange::zero();
    }

    /// Places the cursor before the character at the given index.
    pub fn place_cursor_before_char(&mut self, index: usize) {
        let pos = index.min(self.text.len());
        self.selection = TextRange::cursor(pos);
    }

    /// Collapses a selection to its start, or moves the cursor one character
    /// to the left (the left arrow key).
    pub fn move_cursor_left(&mut self) {
        let target = if self.has_selection() {
            self.selection.min()
        } else {
            self.prev_grapheme_boundary(self.selection.start)
        };
        self.selection = TextRange::cursor(target);
    }

    /// Collapses a selection to its end, or moves the cursor one character to
    /// the right (the right arrow key).
    pub fn move_cursor_right(&mut self) {
        let target = if self.has_selection() {
            self.selection.max()
        } else {
            self.next_grapheme_boundary(self.selection.end)
        };
        self.selection = TextRange::cursor(target);
    }

    /// Selects all text.
    pub fn select_all(&mut self) {
        self.selection = TextRange::all(self.text.len());
    }

    /// Extends the selection one character to the left.
    ///
    /// `start` is the anchor and `end` is the moving cursor, which is what
    /// makes this and [`Self::extend_selection_right`] inverses of each other:
    /// shift-left followed by shift-right returns to where it began. Moving
    /// whichever end happens to be smaller instead would leave the two growing
    /// from opposite ends, and shift-right after shift-left would grow the
    /// selection rather than shrink it.
    ///
    /// A reverse range (`start > end`) is how an anchor to the right of the
    /// cursor is represented; see [`TextRange`].
    pub fn extend_selection_left(&mut self) {
        if self.selection.end > 0 {
            let cursor = self.prev_grapheme_boundary(self.selection.end);
            self.selection = TextRange::new(self.selection.start, cursor);
        }
    }

    /// Extends the selection one character to the right.
    ///
    /// The anchor stays where it is and the cursor moves; see
    /// [`Self::extend_selection_left`].
    pub fn extend_selection_right(&mut self) {
        if self.selection.end < self.text.len() {
            let cursor = self.next_grapheme_boundary(self.selection.end);
            self.selection = TextRange::new(self.selection.start, cursor);
        }
    }

    /// Selects the given range.
    pub fn select(&mut self, range: TextRange) {
        self.selection = range.coerce_in(self.text.len());
    }

    /// Sets the composition (IME) range.
    pub fn set_composition(&mut self, range: Option<TextRange>) {
        self.composition = range.map(|r| r.coerce_in(self.text.len()));
    }

    /// The cursor holds the whole text as its one chunk, so it never asks
    /// for more context and a step always succeeds.
    fn grapheme_cursor(&self, from: usize) -> GraphemeCursor {
        let from = self.text.floor_char_boundary(from);
        GraphemeCursor::new(from, self.text.len(), true)
    }

    fn prev_grapheme_boundary(&self, from: usize) -> usize {
        self.grapheme_cursor(from)
            .prev_boundary(&self.text, 0)
            .ok()
            .flatten()
            .unwrap_or(0)
    }

    fn next_grapheme_boundary(&self, from: usize) -> usize {
        self.grapheme_cursor(from)
            .next_boundary(&self.text, 0)
            .ok()
            .flatten()
            .unwrap_or(self.text.len())
    }

    pub(crate) fn into_value(self) -> TextFieldValue {
        TextFieldValue {
            text: self.text,
            selection: self.selection,
            composition: self.composition,
        }
    }

    /// Returns the selected text for copy operations.
    /// Returns None if no selection.
    pub fn copy_selection(&self) -> Option<String> {
        if !self.has_selection() {
            return None;
        }

        let sel_start = self.selection.min();
        let sel_end = self.selection.max();
        Some(self.text[sel_start..sel_end].to_string())
    }

    /// Cuts the selected text (returns it and deletes from buffer).
    /// Returns the cut text, or None if no selection.
    pub fn cut_selection(&mut self) -> Option<String> {
        let copied = self.copy_selection();
        if copied.is_some() {
            self.delete(self.selection);
            self.has_changes = true;
        }
        copied
    }
}

impl Default for TextFieldBuffer {
    fn default() -> Self {
        Self::new("")
    }
}

#[cfg(test)]
#[path = "tests/buffer_tests.rs"]
mod tests;