indigo_core/

selection.rs

use crate::{
    cursor::CursorState,
    range::{Range, RangeEdit, RangeMove, RangeSnapshot, RangeState},
    rope::{LINE_TYPE, RegexCursorInput, RopeExt as _},
    text::Text,
};
use indigo_kernel::edit::{self, Edit};
use indigo_wrap::{WMut, WRef, Wrap, WrapMut, WrapRef};
use regex_cursor::engines::meta::Regex;
use ropey::{Rope, RopeSlice};
use std::{cmp::max, iter::zip, mem, thread};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum Error {
    #[error("Selection has no ranges")]
    Empty,

    #[error("Primary range index {index} is not within {length} ranges")]
    PrimaryOutOfRange { index: usize, length: usize },

    #[error("Range {index} starts before the range preceding it")]
    Unsorted { index: usize },

    #[error("Error from range {index}")]
    Range {
        index: usize,
        #[source]
        source: anyhow::Error,
    },
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PasteMode {
    Before,
    After,
    Replace,
}

fn is_linewise(values: &[String], paste_mode: PasteMode) -> bool {
    paste_mode != PasteMode::Replace && values.iter().all(|value| value.ends_with('\n'))
}

#[derive(Clone)]
pub struct SelectionState {
    pub ranges: Vec<RangeState>,
    pub primary_range: usize,
}

impl SelectionState {
    pub fn transform(&mut self, ops: &Edit, text: &Rope) {
        let mut offsets: Vec<usize> = self
            .ranges
            .iter()
            .flat_map(|range| [range.tail.byte_index, range.head.byte_index])
            .collect();

        ops.map_positions(&mut offsets, edit::Bias::Forward);

        for (i, range) in self.ranges.iter_mut().enumerate() {
            range.tail.byte_index = text
                .snap_to_grapheme_start(offsets[i * 2])
                .expect("Text is never empty");
            range.head.byte_index = text
                .snap_to_grapheme_start(offsets[i * 2 + 1])
                .expect("Text is never empty");
            range.goal_column = None;
        }
    }

    pub fn sort(&mut self) {
        let mut ranges: Vec<_> = mem::take(&mut self.ranges)
            .into_iter()
            .enumerate()
            .collect();
        ranges.sort_by_key(|(_, range)| (range.start().byte_index, range.end().byte_index));
        self.primary_range = ranges
            .iter()
            .position(|(i, _)| *i == self.primary_range)
            .expect("Primary range index is always kept valid");
        self.ranges = ranges.into_iter().map(|(_, range)| range).collect();
    }

    /// Merge sorted ranges sharing a grapheme into the earlier range. Ranges that merely touch
    /// stay separate. The primary range follows the range it merges into.
    ///
    /// When to merge:
    ///
    /// - Merge after selection motions and seeks (e.g. `h`/`j`/`k`/`l`/`f`/`t`/`x`, mouse
    ///   clicks/drags, etc).
    /// - Merge after `<a-o>`/`<a-O>`, which edit the buffer without entering insert mode.
    /// - Merge before `d`/`c`/`r`, but not after, so cursors that coincide after deleting stay
    ///   separate.
    /// - Merge after undo and redo. Kakoune instead replaces the selection with the modified
    ///   ranges, which are always merged.
    /// - Merge before `R`. Kakoune doesn't; it replaces one range at a time, so coincident
    ///   cursors replace successive graphemes. Merging keeps `R` a single edit, for now.
    ///
    /// When not to merge:
    ///
    /// - Never merge in insert mode or when entering it (`i`/`a`/`I`/`A`/`o`/`O`), so coincident
    ///   cursors each insert their own text. Kakoune does merge on insert-mode cursor movement
    ///   (e.g. arrows), which Indigo doesn't support yet.
    /// - Never merge after `;`, `<a-;>`, or `<a-:>`.
    /// - Never merge after `s` or `<a-s>`; they only sort.
    ///
    /// Except for `R`, we follow Kakoune.
    pub fn merge_overlapping(&mut self) {
        let mut primary_range = 0;
        for (i, range) in mem::take(&mut self.ranges).into_iter().enumerate() {
            if let Some(last) = self.ranges.last_mut()
                && range.start().byte_index <= last.end().byte_index
            {
                let end = max(last.end().byte_index, range.end().byte_index);
                *last = last.with_bounds(last.start().byte_index, end);
            } else {
                self.ranges.push(range);
            }
            if i == self.primary_range {
                primary_range = self.ranges.len() - 1;
            }
        }
        self.primary_range = primary_range;
    }

    /// Whether every range in `other` lies within the range at the same index in `self`.
    #[must_use]
    pub fn contains(&self, other: &Self) -> bool {
        self.ranges.len() == other.ranges.len()
            && zip(&self.ranges, &other.ranges).all(|(outer, inner)| outer.contains(inner))
    }

    #[must_use]
    pub fn save(&self, text: &Text) -> SelectionSnapshot {
        let ranges = self.ranges.iter().map(|range| range.save(text)).collect();
        let primary_range = self.primary_range;
        SelectionSnapshot {
            ranges,
            primary_range,
        }
    }
}

impl Default for SelectionState {
    fn default() -> Self {
        Self {
            ranges: vec![RangeState::default()],
            primary_range: 0,
        }
    }
}

pub struct SelectionSnapshot {
    pub ranges: Vec<RangeSnapshot>,
    pub primary_range: usize,
}

impl SelectionSnapshot {
    #[must_use]
    pub fn restore(&self, text: &Text) -> Option<SelectionState> {
        let ranges = self.ranges.iter().try_fold(
            Vec::with_capacity(self.ranges.len()),
            |mut ranges, range| {
                ranges.push(range.restore(text)?);
                Some(ranges)
            },
        )?;
        let primary_range = self.primary_range;
        Some(SelectionState {
            ranges,
            primary_range,
        })
    }
}

#[must_use]
pub struct SelectionView<'a, S: Wrap, T: Wrap> {
    state: S::Wrap<'a, SelectionState>,
    text: T::Wrap<'a, Text>,
    #[expect(clippy::type_complexity)]
    on_drop: Option<Box<dyn FnOnce(&mut Self) + 'a>>,
}

pub type Selection<'a> = SelectionView<'a, WRef, WRef>;

pub type SelectionMove<'a> = SelectionView<'a, WMut, WRef>;

pub type SelectionEdit<'a> = SelectionView<'a, WMut, WMut>;

impl<'a, S: Wrap, T: Wrap> SelectionView<'a, S, T> {
    pub fn on_drop(mut self, f: impl FnOnce(&mut Self) + 'a) -> Self {
        self.on_drop = Some(Box::new(f));
        self
    }
}

impl<'a, S: WrapRef, T: WrapRef> SelectionView<'a, S, T> {
    pub fn new(
        text: T::WrapRef<'a, Text>,
        state: S::WrapRef<'a, SelectionState>,
    ) -> anyhow::Result<Self> {
        let selection_view = Self {
            state,
            text,
            on_drop: None,
        };
        selection_view.assert_invariants()?;
        Ok(selection_view)
    }

    pub fn text(&self) -> &Text {
        &self.text
    }

    pub fn state(&self) -> &SelectionState {
        &self.state
    }

    pub fn get(&self, index: usize) -> Option<Range<'_>> {
        let range_state = self.state.ranges.get(index)?;
        let range = Range::new(&self.text, range_state)
            .expect("Selection text and range state are always kept valid");
        Some(range)
    }

    pub fn get_primary(&self) -> Range<'_> {
        self.get(self.state.primary_range)
            .expect("Primary range index is always kept valid")
    }

    pub fn for_each(&self, mut f: impl FnMut(usize, Range<'_>)) {
        for (i, range_state) in self.state.ranges.iter().enumerate() {
            let range = Range::new(&self.text, range_state)
                .expect("Selection text and range state are always kept valid");
            f(i, range);
        }
    }

    pub fn contents(&self) -> impl Iterator<Item = RopeSlice<'_>> {
        self.state.ranges.iter().map(|range| {
            let start = range.start().byte_index;
            self.text.slice(start..self.end_exclusive(range))
        })
    }

    /// The exclusive byte offset one past a range's last grapheme.
    fn end_exclusive(&self, range: &RangeState) -> usize {
        self.text
            .next_grapheme_boundary(range.end().byte_index)
            .expect("Range end is always on a grapheme")
    }

    pub fn assert_invariants(&self) -> anyhow::Result<()> {
        if self.state.ranges.is_empty() {
            anyhow::bail!(Error::Empty);
        }
        if self.state.primary_range >= self.state.ranges.len() {
            anyhow::bail!(Error::PrimaryOutOfRange {
                index: self.state.primary_range,
                length: self.state.ranges.len(),
            });
        }
        for (index, range_state) in self.state.ranges.iter().enumerate() {
            let _ = Range::new(&self.text, range_state)
                .map_err(|source| Error::Range { index, source })?;
        }
        let ranges = &self.state.ranges;
        for (index, (previous, range)) in zip(ranges, &ranges[1..]).enumerate() {
            if range.start().byte_index < previous.start().byte_index {
                anyhow::bail!(Error::Unsorted { index: index + 1 });
            }
        }
        Ok(())
    }
}

impl<S: WrapMut, T: WrapRef> SelectionView<'_, S, T> {
    fn unchecked_get_move(&mut self, index: usize) -> Option<RangeMove<'_>> {
        let range_state = self.state.ranges.get_mut(index)?;
        let range = RangeMove::new(&self.text, range_state)
            .expect("Selection text and range state are always kept valid")
            .on_drop(|range| range.assert_invariants().unwrap());
        Some(range)
    }

    pub fn for_each_move(&mut self, mut f: impl FnMut(RangeMove<'_>)) {
        for i in 0..self.state.ranges.len() {
            let range = self.unchecked_get_move(i).unwrap();
            f(range);
        }
        self.state.sort();
    }

    pub fn merge_overlapping(&mut self) {
        self.state.merge_overlapping();
    }

    pub fn keep_primary(&mut self) {
        if self.state.primary_range != 0 {
            let index = self.state.primary_range;
            self.state.ranges.swap(0, index);
            self.state.primary_range = 0;
        }
        self.state.ranges.truncate(1);
    }

    pub fn rotate_forward(&mut self, count: usize) {
        self.state.primary_range = (self.state.primary_range + count) % self.state.ranges.len();
    }

    pub fn rotate_backward(&mut self, count: usize) {
        let length = self.state.ranges.len();
        self.state.primary_range = (self.state.primary_range + length - (count % length)) % length;
    }

    /// Select every regex match within each range. Empty (zero-width) matches become
    /// one-grapheme selections at the match position, as in Kakoune. Returns `false` and leaves
    /// the selection unmodified when nothing matched.
    pub fn select_regex(&mut self, regex: &Regex) -> bool {
        let mut ranges = Vec::new();
        for range_state in &self.state.ranges {
            let rope = self.text.rope();
            let start = range_state.start().byte_index;
            let end_exclusive = rope
                .next_grapheme_boundary(range_state.end().byte_index)
                .expect("Range end is always on a grapheme");
            let slice_length = end_exclusive - start;
            let input =
                regex_cursor::Input::new(RegexCursorInput::from(rope.slice(start..end_exclusive)));
            for needle in regex.find_iter(input) {
                // Skip an empty match one past the searched slice (Kakoune does the same);
                // there is no grapheme there to select.
                if needle.start() >= slice_length {
                    continue;
                }
                let tail_index = rope.floor_grapheme_boundary(start + needle.start());
                let head_index = if needle.start() == needle.end() {
                    // An inclusive range can't be zero-width; select the grapheme at the
                    // match position.
                    tail_index
                } else {
                    // The inclusive end is the last grapheme the match touches.
                    rope.prev_grapheme_boundary(start + needle.end())
                        .unwrap_or(0)
                        .max(tail_index)
                };
                // Preserve the original range's direction, like Kakoune's `keep_direction`.
                let (tail, head) = if range_state.is_forward() {
                    (tail_index, head_index)
                } else {
                    (head_index, tail_index)
                };
                ranges.push(RangeState {
                    tail: CursorState { byte_index: tail },
                    head: CursorState { byte_index: head },
                    goal_column: None,
                });
            }
        }
        let matched = !ranges.is_empty();
        if matched {
            self.state.primary_range = ranges.len() - 1;
            self.state.ranges = ranges;
            self.state.sort();
        }
        matched
    }

    pub fn select_all(&mut self) {
        let mut range = RangeState::default();
        range.head.byte_index = self
            .text
            .last_grapheme_start()
            .expect("Text is never empty");
        self.state.ranges = vec![range];
        self.state.primary_range = 0;
    }

    pub fn split_into_lines(&mut self) {
        self.split_at(|range| {
            let start = range.start().byte_index();
            let end = range.end().byte_index();

            let start_line = range.text().byte_to_line_idx(start, LINE_TYPE);
            let end_line = range.text().byte_to_line_idx(end, LINE_TYPE);

            ((start_line + 1)..=end_line)
                .map(|line| range.text().line_to_byte_idx(line, LINE_TYPE))
                .collect()
        });
    }

    fn split_at(&mut self, mut f: impl FnMut(Range<'_>) -> Vec<usize>) {
        let old_primary_range = self.state.primary_range;
        let old_primary_head = self.state.ranges[old_primary_range].head.byte_index;
        let mut primary_range = 0;
        let mut ranges = Vec::new();

        for range_state in &self.state.ranges {
            let range = Range::new(&self.text, range_state)
                .expect("Selection text and range state are always kept valid");

            let start = range.start().byte_index();
            let end = range.end().byte_index();

            let mut boundaries = f(range);
            boundaries.sort_unstable();
            boundaries.dedup();
            boundaries.retain(|boundary| start < *boundary && *boundary <= end);

            let mut segment_start = start;
            for boundary in boundaries {
                let segment_end = self
                    .text
                    .prev_grapheme_boundary(boundary)
                    .expect("Cut point is after the range start");
                ranges.push(range_state.with_bounds(segment_start, segment_end));
                segment_start = boundary;
            }
            ranges.push(range_state.with_bounds(segment_start, end));
        }

        for (i, range) in ranges.iter().enumerate() {
            if range.head.byte_index == old_primary_head {
                primary_range = i;
                break;
            }
        }

        self.state.ranges = ranges;
        self.state.primary_range = primary_range;
        self.state.sort();
    }

    fn invalidate_goal_columns(&mut self) {
        for i in 0..self.state.ranges.len() {
            let mut range = self.unchecked_get_move(i).unwrap();
            range.invalidate_goal_column();
        }
    }
}

impl<S: WrapMut, T: WrapMut> SelectionView<'_, S, T> {
    fn unchecked_get_edit(&mut self, index: usize) -> Option<RangeEdit<'_>> {
        let range_state = self.state.ranges.get_mut(index)?;
        let range = RangeEdit::new(&mut self.text, range_state)
            .expect("Selection text and range state are always kept valid")
            .on_drop(|range| range.assert_invariants().unwrap());
        Some(range)
    }

    pub fn for_each_edit(&mut self, mut f: impl FnMut(RangeEdit<'_>)) {
        for i in 0..self.state.ranges.len() {
            let version = self.text.version();
            let range = self.unchecked_get_edit(i).unwrap();
            f(range);
            if let Some(opss) = self.text.ops_since(version) {
                for j in 0..self.state.ranges.len() {
                    if i == j {
                        continue;
                    }
                    for ops in opss {
                        self.state.ranges[j].transform(ops, &self.text);
                    }
                }
            }
        }
        self.state.sort();
    }

    pub fn insert_char(&mut self, char: char) -> Edit {
        self.insert(&char.to_string())
    }

    pub fn insert(&mut self, text: &str) -> Edit {
        let mut ops = Edit::new();
        let mut previous = 0;
        for range in &self.state.ranges {
            // TODO: Assert grapheme length is 1 (i.e. collapsed)
            ops.retain(range.start().byte_index - previous);
            ops.insert(text);
            previous = range.start().byte_index;
        }
        ops.retain_rest(&self.text)
            .expect("Operations fit within text");
        self.text.apply(&ops).expect("Operations are well formed");
        self.state.transform(&ops, &self.text);
        self.invalidate_goal_columns();
        ops
    }

    pub fn paste(&mut self, values: &[String], paste_mode: PasteMode) -> Edit {
        const NOTHING: &[String] = &[String::new()];
        let values = if values.is_empty() { NOTHING } else { values };
        self.paste_with(values, paste_mode, is_linewise(values, paste_mode))
    }

    /// Paste every value at each range, then select each value separately (like Kakoune).
    pub fn paste_all(&mut self, values: &[String], paste_mode: PasteMode) -> Edit {
        if values.is_empty() {
            return Edit::identity(&self.text);
        }
        let linewise = is_linewise(values, paste_mode);
        let ops = self.paste_with(&[values.concat()], paste_mode, linewise);
        let mut ranges = Vec::with_capacity(self.state.ranges.len() * values.len());
        for range in &self.state.ranges {
            let mut start = range.start().byte_index;
            for value in values {
                let last = max(start, (start + value.len()).saturating_sub(1));
                ranges.push(
                    range.with_bounds(
                        self.text
                            .snap_to_grapheme_start(start)
                            .expect("Text is never empty"),
                        self.text
                            .snap_to_grapheme_start(last)
                            .expect("Text is never empty"),
                    ),
                );
                start += value.len();
            }
        }
        self.state.ranges = ranges;
        // The last value pasted at the primary range becomes primary.
        self.state.primary_range = self.state.primary_range * values.len() + values.len() - 1;
        ops
    }

    fn paste_with(&mut self, values: &[String], paste_mode: PasteMode, linewise: bool) -> Edit {
        if paste_mode == PasteMode::Replace {
            // Unlike Kakoune; see `SelectionState::merge_overlapping`.
            self.state.merge_overlapping();
        }
        debug_assert!(
            paste_mode == PasteMode::Before
                || self
                    .state
                    .ranges
                    .is_sorted_by_key(|range| range.end().byte_index),
            "pasting after relies on selection ranges' ends being sorted",
        );
        let mut ops = Edit::new();
        let mut previous = 0;
        let mut output_position = 0;
        // The last byte of the output so far, to keep the `Text` invariant.
        let mut last_byte = None;
        let mut spans = Vec::with_capacity(self.state.ranges.len());
        for (i, range) in self.state.ranges.iter().enumerate() {
            // The text to replace; empty when only inserting.
            let at = |offset| offset..offset;
            let replaced = match (paste_mode, linewise) {
                (PasteMode::Before, false) => at(range.start().byte_index),
                (PasteMode::Before, true) => {
                    let line = self
                        .text
                        .byte_to_line_idx(range.start().byte_index, LINE_TYPE);
                    at(self.text.line_to_byte_idx(line, LINE_TYPE))
                }
                (PasteMode::After, false) => at(self.end_exclusive(range)),
                (PasteMode::After, true) => {
                    let line = self
                        .text
                        .byte_to_line_idx(range.end().byte_index, LINE_TYPE);
                    at(self.text.line_to_byte_idx(line + 1, LINE_TYPE))
                }
                (PasteMode::Replace, _) => range.start().byte_index..self.end_exclusive(range),
            };
            let retained = replaced.start - previous;
            ops.retain(retained);
            output_position += retained;
            if retained > 0 {
                last_byte = Some(self.text.byte(replaced.start - 1));
            }
            let start = output_position;
            let value = &values[i % values.len()];
            let old = self.text.slice(replaced.clone());
            if old == value.as_str() {
                // Like Kakoune, replacing text with itself isn't an edit.
                ops.retain(old.len());
            } else {
                ops.delete(&old.to_string());
                ops.insert(value);
            }
            output_position += value.len();
            if let Some(&byte) = value.as_bytes().last() {
                last_byte = Some(byte);
            }
            if replaced.end == self.text.len() && last_byte != Some(b'\n') {
                // The edit reaches the end of the text; restore the `Text` invariant.
                ops.insert("\n");
                output_position += 1;
                last_byte = Some(b'\n');
            }
            // Like Kakoune, pasting selects a restored final newline, but replacing doesn't.
            let end = if paste_mode == PasteMode::Replace {
                start + value.len()
            } else {
                output_position
            };
            spans.push((start, end));
            previous = replaced.end;
        }
        ops.retain_rest(&self.text)
            .expect("Operations fit within text");
        // A paste that changes nothing only moves the selection; keep it out of the history.
        if ops != Edit::identity(&self.text) {
            self.text.apply(&ops).expect("Operations are well formed");
        }
        for (range, (start, end_exclusive)) in zip(&mut self.state.ranges, spans) {
            // An empty value selects the insertion point.
            let last = max(start, end_exclusive.saturating_sub(1));
            let start = self
                .text
                .snap_to_grapheme_start(start)
                .expect("Text is never empty");
            let end = self
                .text
                .snap_to_grapheme_start(last)
                .expect("Text is never empty");
            *range = range.with_bounds(start, end);
        }
        self.invalidate_goal_columns();
        ops
    }

    pub fn replace_each(&mut self, byte: u8) -> Edit {
        self.state.merge_overlapping();
        let replacement = char::from(byte).to_string();
        let mut ops = Edit::new();
        let mut previous = 0;
        let mut output_position = 0;
        let mut ranges = Vec::with_capacity(self.state.ranges.len());
        for range in &self.state.ranges {
            let start = range.start().byte_index;
            let end_exclusive = self
                .text
                .next_grapheme_boundary(range.end().byte_index)
                .expect("Range end is always on a grapheme");
            let retained = start - previous;
            ops.retain(retained);
            output_position += retained;
            let replacement_start = output_position;
            for grapheme in self.text.rope().slice(start..end_exclusive).graphemes() {
                ops.delete(&grapheme.to_string());
                ops.insert(&replacement);
                output_position += replacement.len();
            }
            ranges.push(range.with_bounds(replacement_start, output_position - replacement.len()));
            if end_exclusive == self.text.len() {
                // The final newline was replaced; restore the `Text` invariant.
                ops.insert("\n");
            }
            previous = end_exclusive;
        }
        ops.retain_rest(&self.text)
            .expect("Operations fit within text");
        self.text.apply(&ops).expect("Operations are well formed");
        self.state.ranges = ranges;
        self.invalidate_goal_columns();
        ops
    }

    pub fn delete_before(&mut self) -> Edit {
        let mut ops = Edit::new();
        let mut previous = 0;
        for range in &self.state.ranges {
            let start = range.start().byte_index;
            if let Some(prev_boundary) = self.text.prev_grapheme_boundary(start)
                && prev_boundary >= previous
            {
                ops.retain(prev_boundary - previous);
                ops.delete(&self.text.slice(prev_boundary..start).to_string());
                previous = start;
            }
        }
        ops.retain_rest(&self.text)
            .expect("Operations fit within text");
        self.text.apply(&ops).expect("Operations are well formed");
        self.state.transform(&ops, &self.text);
        self.invalidate_goal_columns();
        ops
    }

    pub fn delete(&mut self) -> Edit {
        self.state.merge_overlapping();
        let spans: Vec<(usize, usize)> = self
            .state
            .ranges
            .iter()
            .map(|range| (range.start().byte_index, self.end_exclusive(range)))
            .collect();
        let mut ops = Edit::new();
        let mut previous = 0;
        for &(start, end_exclusive) in &spans {
            ops.retain(start - previous);
            ops.delete(&self.text.slice(start..end_exclusive).to_string());
            previous = end_exclusive;
        }
        // If the deletions reach the end of the text, the last surviving byte must still be a
        // newline; otherwise re-insert one. Walk back through ranges that abut each other to
        // find the last surviving byte.
        if let Some(&(_, last_end_exclusive)) = spans.last()
            && last_end_exclusive == self.text.len()
        {
            let mut position = spans[spans.len() - 1].0;
            for &(start, end_exclusive) in spans[..spans.len() - 1].iter().rev() {
                if end_exclusive == position {
                    position = start;
                } else {
                    break;
                }
            }
            if position == 0 || self.text.byte(position - 1) != b'\n' {
                ops.insert("\n");
            }
        }
        ops.retain_rest(&self.text)
            .expect("Operations fit within text");
        self.text.apply(&ops).expect("Operations are well formed");
        self.state.transform(&ops, &self.text);
        self.invalidate_goal_columns();
        ops
    }

    pub fn delete_after(&mut self) -> Edit {
        let mut ops = Edit::new();
        let mut previous = 0;
        for range in &self.state.ranges {
            let end = range.end().byte_index;
            let next_boundary = self
                .text
                .next_grapheme_boundary(end)
                .expect("Range end is always on a grapheme");
            if next_boundary == self.text.len() {
                // Deleting the final newline would break the `Text` invariant.
                continue;
            }
            if end >= previous {
                ops.retain(end - previous);
                ops.delete(&self.text.slice(end..next_boundary).to_string());
                previous = next_boundary;
            }
        }
        ops.retain_rest(&self.text)
            .expect("Operations fit within text");
        self.text.apply(&ops).expect("Operations are well formed");
        self.state.transform(&ops, &self.text);
        self.invalidate_goal_columns();
        ops
    }
}

impl<S: Wrap, T: Wrap> Drop for SelectionView<'_, S, T> {
    fn drop(&mut self) {
        if !thread::panicking()
            && let Some(f) = self.on_drop.take()
        {
            f(self);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use hegel::generators as gs;
    use std::collections::BTreeSet;

    fn range(tail: usize, head: usize) -> RangeState {
        RangeState {
            tail: CursorState { byte_index: tail },
            head: CursorState { byte_index: head },
            goal_column: None,
        }
    }

    fn split_ranges(text: &str, ranges: Vec<RangeState>) -> SelectionState {
        let mut text = Text::from(text);
        let mut state = SelectionState {
            ranges,
            primary_range: 0,
        };
        SelectionEdit::new(&mut text, &mut state)
            .unwrap()
            .split_into_lines();
        state
    }

    #[hegel::test(test_cases = 5_000)]
    fn sort_and_merge_overlapping_ranges(tc: hegel::TestCase) {
        let count = tc.draw(gs::integers::<usize>().min_value(1).max_value(8));
        let ranges: Vec<RangeState> = (0..count)
            .map(|_| {
                let tail = tc.draw(gs::integers::<usize>().max_value(20));
                let head = tc.draw(gs::integers::<usize>().max_value(20));
                range(tail, head)
            })
            .collect();
        let primary_range = tc.draw(gs::integers::<usize>().max_value(count - 1));
        let covered = |ranges: &[RangeState]| -> BTreeSet<usize> {
            ranges
                .iter()
                .flat_map(|range| range.start().byte_index..=range.end().byte_index)
                .collect()
        };

        let mut state = SelectionState {
            ranges: ranges.clone(),
            primary_range,
        };
        state.sort();
        state.merge_overlapping();

        for (previous, range) in zip(&state.ranges, &state.ranges[1..]) {
            assert!(
                previous.end().byte_index < range.start().byte_index,
                "Ranges are sorted and share no grapheme"
            );
        }
        assert_eq!(covered(&ranges), covered(&state.ranges));
        assert!(state.ranges[state.primary_range].contains(&ranges[primary_range]));
        assert!(
            state
                .ranges
                .iter()
                .all(|range| ranges.iter().any(|original| {
                    original.start().byte_index == range.start().byte_index
                        && original.is_forward() == range.is_forward()
                })),
            "A merged range keeps the direction of its earliest range"
        );
    }

    #[test]
    fn split_into_lines_keeps_partial_endpoints() {
        // Selects from "b" through the "o" on the third line (inclusive).
        let state = split_ranges("abcdef\nghijkl\nmnopqr\n", vec![range(1, 15)]);

        assert_eq!(state.primary_range, 2);
        assert_eq!(state.ranges.len(), 3);
        assert_eq!(state.ranges[0].tail.byte_index, 1);
        assert_eq!(state.ranges[0].head.byte_index, 6);
        assert_eq!(state.ranges[1].tail.byte_index, 7);
        assert_eq!(state.ranges[1].head.byte_index, 13);
        assert_eq!(state.ranges[2].tail.byte_index, 14);
        assert_eq!(state.ranges[2].head.byte_index, 15);
    }

    #[test]
    fn split_into_lines_preserves_backward_direction() {
        let state = split_ranges("abcdef\nghijkl\nmnopqr\n", vec![range(15, 1)]);

        assert_eq!(state.primary_range, 0);
        assert_eq!(state.ranges.len(), 3);
        assert_eq!(state.ranges[0].tail.byte_index, 6);
        assert_eq!(state.ranges[0].head.byte_index, 1);
        assert_eq!(state.ranges[1].tail.byte_index, 13);
        assert_eq!(state.ranges[1].head.byte_index, 7);
        assert_eq!(state.ranges[2].tail.byte_index, 15);
        assert_eq!(state.ranges[2].head.byte_index, 14);
    }

    #[test]
    fn replace_each_replaces_newlines() {
        // Kakoune's `r` replaces newlines too; replacing the final newline re-inserts one.
        let mut text = Text::from("ab\ncd\n");
        let mut state = SelectionState::default();
        let mut selection = SelectionEdit::new(&mut text, &mut state).unwrap();
        selection.select_all();
        selection.replace_each(b'X');
        drop(selection);
        assert_eq!(&text.to_string(), "XXXXXX\n");
        assert_eq!(state.ranges[0].tail.byte_index, 0);
        assert_eq!(state.ranges[0].head.byte_index, 5);
    }

    #[test]
    fn delete_abutting_ranges_keeps_trailing_newline() {
        // Two abutting ranges together delete through the end of the text ("\nb\n" in total);
        // the last surviving byte ('a') is not a newline, so one is re-inserted.
        let mut text = Text::from("a\nb\n");
        let mut state = SelectionState {
            ranges: vec![range(1, 1), range(2, 3)],
            primary_range: 0,
        };
        let mut selection = SelectionEdit::new(&mut text, &mut state).unwrap();
        selection.delete();
        drop(selection);
        assert_eq!(&text.to_string(), "a\n");
    }

    #[test]
    fn select_regex_empty_matches_select_one_grapheme() {
        // `x*` matches empty at every position; each empty match becomes a one-grapheme
        // selection, and the empty match at the end of the searched slice is skipped.
        let regex = Regex::new("x*").unwrap();
        let mut text = Text::from("abc\n");
        let mut state = SelectionState::default();
        let mut selection = SelectionEdit::new(&mut text, &mut state).unwrap();
        selection.select_all();
        assert!(selection.select_regex(&regex));
        drop(selection);
        let positions: Vec<(usize, usize)> = state
            .ranges
            .iter()
            .map(|range| (range.tail.byte_index, range.head.byte_index))
            .collect();
        assert_eq!(positions, vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
    }

    #[test]
    fn select_regex_no_match_leaves_selection_unmodified() {
        let regex = Regex::new("xyz").unwrap();
        let mut text = Text::from("abc\n");
        let mut state = SelectionState::default();
        let mut selection = SelectionEdit::new(&mut text, &mut state).unwrap();
        selection.select_all();
        assert!(!selection.select_regex(&regex));
        drop(selection);
        assert_eq!(state.ranges.len(), 1);
        assert_eq!(state.ranges[0].tail.byte_index, 0);
        assert_eq!(state.ranges[0].head.byte_index, 3);
    }

    #[test]
    fn select_regex_match_end_is_inclusive() {
        let regex = Regex::new("o+").unwrap();
        let mut text = Text::from("foo bar\n");
        let mut state = SelectionState::default();
        let mut selection = SelectionEdit::new(&mut text, &mut state).unwrap();
        selection.select_all();
        assert!(selection.select_regex(&regex));
        drop(selection);
        assert_eq!(state.ranges.len(), 1);
        assert_eq!(state.ranges[0].tail.byte_index, 1);
        assert_eq!(state.ranges[0].head.byte_index, 2);
    }

    #[test]
    fn split_into_lines_splits_full_lines() {
        // Selecting everything (each line's newline included) splits into whole lines.
        let state = split_ranges("a\nb\nc\n", vec![range(0, 5)]);

        assert_eq!(state.primary_range, 2);
        assert_eq!(state.ranges.len(), 3);
        assert_eq!(state.ranges[0].tail.byte_index, 0);
        assert_eq!(state.ranges[0].head.byte_index, 1);
        assert_eq!(state.ranges[1].tail.byte_index, 2);
        assert_eq!(state.ranges[1].head.byte_index, 3);
        assert_eq!(state.ranges[2].tail.byte_index, 4);
        assert_eq!(state.ranges[2].head.byte_index, 5);
    }
}