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.publish_change(edit, origin);
229        self.trace_edit(origin, start_byte, range.len(), text);
230    }
231
232    fn publish_change(&mut self, edit: InputEdit, origin: ChangeOrigin) {
233        debug_assert!(self.epoch < u64::MAX);
234        self.epoch += 1;
235        self.dirty |= origin != ChangeOrigin::System;
236        self.changes.push(Change {
237            revision: self.revision(),
238            origin,
239            edit,
240        });
241    }
242}
243
244impl UserEdit<'_> {
245    pub fn insert(&mut self, at: impl Into<ByteOffset>, text: &str) -> Result<(), EditError> {
246        let at = at.into();
247        self.replace(Range::charwise(at, at), text)
248    }
249    pub fn delete(&mut self, range: Range) -> Result<String, EditError> {
250        if self.buffer.readonly {
251            return Err(EditError::ReadOnly);
252        }
253        self.buffer.validate_range(range)?;
254        let removed = self.buffer.slice_string(range);
255        self.replace(range, "")?;
256        Ok(removed)
257    }
258    pub fn replace(&mut self, range: Range, text: &str) -> Result<(), EditError> {
259        if self.buffer.readonly {
260            return Err(EditError::ReadOnly);
261        }
262        self.buffer.validate_range(range)?;
263        if range.is_empty() && text.is_empty() {
264            return Ok(());
265        }
266        self.buffer
267            .epoch
268            .checked_add(1)
269            .ok_or(EditError::RevisionExhausted)?;
270        self.buffer
271            .replace_validated(range, text, ChangeOrigin::User);
272        Ok(())
273    }
274}
275
276impl SystemEdit<'_> {
277    /// A generated surface is a new system snapshot, never an undoable user edit.
278    pub fn replace_all(&mut self, text: &str) -> Result<(), EditError> {
279        self.buffer
280            .epoch
281            .checked_add(1)
282            .ok_or(EditError::RevisionExhausted)?;
283        self.buffer.replace_validated(
284            Range::charwise(0, self.buffer.len_bytes()),
285            text,
286            ChangeOrigin::System,
287        );
288        self.buffer.history = Default::default();
289        Ok(())
290    }
291
292    /// Publish worker-built text without flattening or rebuilding a rope on the
293    /// event loop. Identity, readonly policy and monotonic revision stay local.
294    pub fn replace_rope(&mut self, rope: ropey::Rope) -> Result<(), EditError> {
295        self.buffer
296            .epoch
297            .checked_add(1)
298            .ok_or(EditError::RevisionExhausted)?;
299        let old_end_byte = self.buffer.len_bytes();
300        let old_end_point = self.buffer.point_of(old_end_byte);
301        let new_end_byte = rope.len_bytes();
302        let line = rope.byte_to_line(new_end_byte);
303        let new_end_point = (line, new_end_byte - rope.line_to_byte(line));
304        self.buffer.rope = rope;
305        self.buffer.publish_change(
306            InputEdit {
307                start_byte: 0,
308                old_end_byte,
309                new_end_byte,
310                start_point: (0, 0),
311                old_end_point,
312                new_end_point,
313            },
314            ChangeOrigin::System,
315        );
316        self.buffer.history = Default::default();
317        self.buffer.trace_snapshot(old_end_byte);
318        Ok(())
319    }
320}
321
322#[derive(Debug, Clone, Copy)]
323pub struct HistoryMove {
324    pub start: ByteOffset,
325    pub end: ByteOffset,
326}
327
328impl Buffer {
329    pub fn undo(&mut self) -> Result<Option<HistoryMove>, EditError> {
330        self.move_history(crate::history::HistoryAction::Undo)
331    }
332    pub fn redo(&mut self) -> Result<Option<HistoryMove>, EditError> {
333        self.move_history(crate::history::HistoryAction::Redo)
334    }
335    pub fn restore_revision(&mut self, revision: usize) -> Result<Option<HistoryMove>, EditError> {
336        self.move_history(crate::history::HistoryAction::Jump(revision))
337    }
338    fn move_history(
339        &mut self,
340        action: crate::history::HistoryAction,
341    ) -> Result<Option<HistoryMove>, EditError> {
342        if self.readonly {
343            return Err(EditError::ReadOnly);
344        }
345        let Some(cost) = self.history.movement_cost(action) else {
346            return Ok(None);
347        };
348        self.epoch
349            .checked_add(cost as u64)
350            .ok_or(EditError::RevisionExhausted)?;
351        // A valid history is guaranteed by construction and validated at restore.
352        let Some(ops) = self.history.navigate(action) else {
353            return Ok(None);
354        };
355        debug_assert_eq!(cost, ops.len());
356        let start = ops.iter().map(|edit| edit.at).min().unwrap_or(0);
357        let end = ops
358            .last()
359            .map(|edit| {
360                edit.at
361                    + if edit.kind == EditKind::Insert {
362                        edit.text.len()
363                    } else {
364                        0
365                    }
366            })
367            .unwrap_or(start);
368        for op in &ops {
369            let (range, text) = match op.kind {
370                EditKind::Insert => (Range::charwise(op.at, op.at), op.text.as_str()),
371                EditKind::Delete => (Range::charwise(op.at, op.at + op.text.len()), ""),
372            };
373            debug_assert!(self.validate_range(range).is_ok(), "sealed history range");
374            debug_assert!(
375                op.kind != EditKind::Delete
376                    || self.rope.byte_slice(range.start.get()..range.end.get()) == op.text,
377                "sealed history content"
378            );
379            self.replace_validated(range, text, ChangeOrigin::History);
380        }
381        self.trace_history(&ops);
382        Ok(Some(HistoryMove {
383            start: start.into(),
384            end: end.into(),
385        }))
386    }
387}
strop_core/buffer/mutation.rs

strop_core/buffer/
mutation.rs
