strop_core/buffer/
mutation.rs

1//! The only mutable text capability. Every mutation publishes pre-edit geometry.
2use super::Buffer;
3use crate::history::{Edit, EditKind};
4use crate::id::{BufferRevision, ByteOffset};
5use crate::{InputEdit, Range};
6
7#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
8pub enum ChangeOrigin {
9    User,
10    History,
11    System,
12}
13
14#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15pub struct Change {
16    pub revision: BufferRevision,
17    pub origin: ChangeOrigin,
18    pub edit: InputEdit,
19}
20
21#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
22pub enum EditError {
23    #[error("readonly buffer")]
24    ReadOnly,
25    #[error("invalid edit range")]
26    InvalidRange,
27    #[error("overlapping replacements in pre-edit coordinates")]
28    Overlap,
29    #[error("prepared replacement belongs to another buffer")]
30    WrongBuffer,
31    #[error("stale revision: expected {expected}, found {found}")]
32    StaleRevision {
33        expected: BufferRevision,
34        found: BufferRevision,
35    },
36    #[error("buffer revision exhausted")]
37    RevisionExhausted,
38}
39
40#[derive(Debug, Clone, PartialEq, Eq)]
41pub struct Replacement {
42    pub range: Range,
43    pub text: String,
44}
45impl Replacement {
46    pub fn new(range: Range, text: impl Into<String>) -> Self {
47        Self {
48            range,
49            text: text.into(),
50        }
51    }
52}
53
54/// Validated, sorted replacements bound to one exact buffer incarnation/revision.
55/// The editor may restore prompt selection state before acquiring its write lease.
56pub struct PreparedReplacements {
57    buffer: crate::diagnostics::BufferTraceId,
58    revision: BufferRevision,
59    edits: Vec<Replacement>,
60}
61impl PreparedReplacements {
62    pub fn is_empty(&self) -> bool {
63        self.edits.is_empty()
64    }
65}
66
67pub struct UserEdit<'a> {
68    buffer: &'a mut Buffer,
69}
70pub struct SystemEdit<'a> {
71    buffer: &'a mut Buffer,
72}
73
74impl Buffer {
75    pub fn edit(&mut self) -> UserEdit<'_> {
76        UserEdit { buffer: self }
77    }
78    pub fn system_edit(&mut self) -> SystemEdit<'_> {
79        SystemEdit { buffer: self }
80    }
81    pub fn changes(&self) -> &[Change] {
82        &self.changes
83    }
84    pub fn clear_changes(&mut self) {
85        self.changes.clear();
86    }
87    pub fn begin_undo_group(&mut self) {
88        self.history.begin();
89    }
90    pub fn commit_undo_group(&mut self) {
91        self.history.commit();
92    }
93
94    fn validate_range(&self, range: Range) -> Result<(), EditError> {
95        if range.start > range.end || !self.is_boundary(range.start) || !self.is_boundary(range.end)
96        {
97            return Err(EditError::InvalidRange);
98        }
99        Ok(())
100    }
101
102    /// All replacements refer to one pre-edit snapshot. Validate the whole batch
103    /// before opening history or touching text; reversed application preserves coordinates.
104    pub fn prepare_replacements(
105        &self,
106        base: BufferRevision,
107        mut replacements: Vec<Replacement>,
108    ) -> Result<PreparedReplacements, EditError> {
109        if self.readonly {
110            return Err(EditError::ReadOnly);
111        }
112        if base != self.revision() {
113            return Err(EditError::StaleRevision {
114                expected: base,
115                found: self.revision(),
116            });
117        }
118        replacements.retain(|edit| !edit.range.is_empty() || !edit.text.is_empty());
119        replacements.sort_unstable_by_key(|edit| edit.range.start);
120        for edit in &replacements {
121            self.validate_range(edit.range)?;
122        }
123        for pair in replacements.windows(2) {
124            if pair[0].range.end > pair[1].range.start || pair[0].range.start == pair[1].range.start
125            {
126                return Err(EditError::Overlap);
127            }
128        }
129        self.epoch
130            .checked_add(replacements.len() as u64)
131            .ok_or(EditError::RevisionExhausted)?;
132        Ok(PreparedReplacements {
133            buffer: self.trace_id(),
134            revision: base,
135            edits: replacements,
136        })
137    }
138
139    pub fn apply_prepared(
140        &mut self,
141        prepared: PreparedReplacements,
142        undo_open: bool,
143    ) -> Result<BufferRevision, EditError> {
144        if prepared.buffer != self.trace_id() {
145            return Err(EditError::WrongBuffer);
146        }
147        if self.readonly {
148            return Err(EditError::ReadOnly);
149        }
150        if prepared.revision != self.revision() {
151            return Err(EditError::StaleRevision {
152                expected: prepared.revision,
153                found: self.revision(),
154            });
155        }
156        if prepared.is_empty() {
157            return Ok(self.revision());
158        }
159        self.history.begin();
160        for replacement in prepared.edits.into_iter().rev() {
161            self.replace_validated(replacement.range, &replacement.text, ChangeOrigin::User);
162        }
163        if !undo_open {
164            self.history.commit();
165        }
166        Ok(self.revision())
167    }
168
169    fn replace_validated(&mut self, range: Range, text: &str, origin: ChangeOrigin) {
170        debug_assert!(self.validate_range(range).is_ok());
171        debug_assert!(self.epoch < u64::MAX);
172        let (start_byte, end_byte) = (range.start.get(), range.end.get());
173        let start_point = self.point_of(start_byte);
174        let old_end_point = self.point_of(end_byte);
175        let extent = Self::point_extent(text);
176        let new_end_point = if extent.0 == 0 {
177            (start_point.0, start_point.1 + extent.1)
178        } else {
179            (start_point.0 + extent.0, extent.1)
180        };
181        let edit = InputEdit {
182            start_byte,
183            old_end_byte: end_byte,
184            new_end_byte: start_byte + text.len(),
185            start_point,
186            old_end_point,
187            new_end_point,
188        };
189        if origin == ChangeOrigin::User {
190            if !range.is_empty() {
191                let removed = self.rope.byte_slice(start_byte..end_byte).to_string();
192                self.history.record(
193                    Edit {
194                        at: start_byte,
195                        text: removed.clone(),
196                        kind: EditKind::Insert,
197                    },
198                    Edit {
199                        at: start_byte,
200                        text: removed,
201                        kind: EditKind::Delete,
202                    },
203                );
204            }
205            if !text.is_empty() {
206                self.history.record(
207                    Edit {
208                        at: start_byte,
209                        text: text.into(),
210                        kind: EditKind::Delete,
211                    },
212                    Edit {
213                        at: start_byte,
214                        text: text.into(),
215                        kind: EditKind::Insert,
216                    },
217                );
218            }
219        }
220        let start = self.rope.byte_to_char(start_byte);
221        let end = self.rope.byte_to_char(end_byte);
222        if start != end {
223            self.rope.remove(start..end);
224        }
225        if !text.is_empty() {
226            self.rope.insert(start, text);
227        }
228        self.epoch += 1;
229        self.dirty |= origin != ChangeOrigin::System;
230        self.changes.push(Change {
231            revision: self.revision(),
232            origin,
233            edit,
234        });
235        self.trace_edit(origin, start_byte, range.len(), text);
236    }
237}
238
239impl UserEdit<'_> {
240    pub fn insert(&mut self, at: impl Into<ByteOffset>, text: &str) -> Result<(), EditError> {
241        let at = at.into();
242        self.replace(Range::charwise(at, at), text)
243    }
244    pub fn delete(&mut self, range: Range) -> Result<String, EditError> {
245        if self.buffer.readonly {
246            return Err(EditError::ReadOnly);
247        }
248        self.buffer.validate_range(range)?;
249        let removed = self.buffer.slice_string(range);
250        self.replace(range, "")?;
251        Ok(removed)
252    }
253    pub fn replace(&mut self, range: Range, text: &str) -> Result<(), EditError> {
254        if self.buffer.readonly {
255            return Err(EditError::ReadOnly);
256        }
257        self.buffer.validate_range(range)?;
258        if range.is_empty() && text.is_empty() {
259            return Ok(());
260        }
261        self.buffer
262            .epoch
263            .checked_add(1)
264            .ok_or(EditError::RevisionExhausted)?;
265        self.buffer
266            .replace_validated(range, text, ChangeOrigin::User);
267        Ok(())
268    }
269}
270
271impl SystemEdit<'_> {
272    /// A generated surface is a new system snapshot, never an undoable user edit.
273    pub fn replace_all(&mut self, text: &str) -> Result<(), EditError> {
274        self.buffer
275            .epoch
276            .checked_add(1)
277            .ok_or(EditError::RevisionExhausted)?;
278        self.buffer.replace_validated(
279            Range::charwise(0, self.buffer.len_bytes()),
280            text,
281            ChangeOrigin::System,
282        );
283        self.buffer.history = Default::default();
284        Ok(())
285    }
286}
287
288#[derive(Debug, Clone, Copy)]
289pub struct HistoryMove {
290    pub start: ByteOffset,
291    pub end: ByteOffset,
292}
293
294impl Buffer {
295    pub fn undo(&mut self) -> Result<Option<HistoryMove>, EditError> {
296        self.move_history(crate::history::HistoryAction::Undo)
297    }
298    pub fn redo(&mut self) -> Result<Option<HistoryMove>, EditError> {
299        self.move_history(crate::history::HistoryAction::Redo)
300    }
301    pub fn restore_revision(&mut self, revision: usize) -> Result<Option<HistoryMove>, EditError> {
302        self.move_history(crate::history::HistoryAction::Jump(revision))
303    }
304    fn move_history(
305        &mut self,
306        action: crate::history::HistoryAction,
307    ) -> Result<Option<HistoryMove>, EditError> {
308        if self.readonly {
309            return Err(EditError::ReadOnly);
310        }
311        let Some(cost) = self.history.movement_cost(action) else {
312            return Ok(None);
313        };
314        self.epoch
315            .checked_add(cost as u64)
316            .ok_or(EditError::RevisionExhausted)?;
317        // A valid history is guaranteed by construction and validated at restore.
318        let Some(ops) = self.history.navigate(action) else {
319            return Ok(None);
320        };
321        debug_assert_eq!(cost, ops.len());
322        let start = ops.iter().map(|edit| edit.at).min().unwrap_or(0);
323        let end = ops
324            .last()
325            .map(|edit| {
326                edit.at
327                    + if edit.kind == EditKind::Insert {
328                        edit.text.len()
329                    } else {
330                        0
331                    }
332            })
333            .unwrap_or(start);
334        for op in &ops {
335            let (range, text) = match op.kind {
336                EditKind::Insert => (Range::charwise(op.at, op.at), op.text.as_str()),
337                EditKind::Delete => (Range::charwise(op.at, op.at + op.text.len()), ""),
338            };
339            debug_assert!(self.validate_range(range).is_ok(), "sealed history range");
340            debug_assert!(
341                op.kind != EditKind::Delete
342                    || self.rope.byte_slice(range.start.get()..range.end.get()) == op.text,
343                "sealed history content"
344            );
345            self.replace_validated(range, text, ChangeOrigin::History);
346        }
347        self.trace_history(&ops);
348        Ok(Some(HistoryMove {
349            start: start.into(),
350            end: end.into(),
351        }))
352    }
353}
strop_core/buffer/mutation.rs

strop_core/buffer/
mutation.rs
