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

strop_core/buffer/
mutation.rs
