use std::ops::Range;
use std::sync::{Arc, Weak};
use parking_lot::Mutex;
use frontend::commands::undo_redo_commands;
use crate::cursor::{Recording, TextCursor};
use crate::document::TextDocument;
use crate::events::{DocumentEvent, InsertionOrigin};
use crate::inner::{CursorData, QueuedEvents, TextDocumentInner, adjust_offset};
use crate::{DocumentError, ReplaceFormatPolicy, Result, TextFormat};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Splice {
pub at: usize,
pub removed: usize,
pub added: usize,
}
impl Splice {
fn then(self, next: Splice) -> Option<Splice> {
let made_end = self.at + self.added;
if next.at > made_end || next.at + next.removed < self.at {
return None;
}
let before = self.at.saturating_sub(next.at);
let after = (next.at + next.removed).saturating_sub(made_end);
let inside = next.removed.saturating_sub(before + after);
Some(Splice {
at: self.at.min(next.at),
removed: before + self.removed + after,
added: self.added.saturating_sub(inside) + next.added,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Span {
start: usize,
end: usize,
recorded_end: usize,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Stand {
position: usize,
anchor: usize,
anchor_in_table: Option<usize>,
}
impl Stand {
fn of(data: &CursorData) -> Self {
Stand {
position: data.position,
anchor: data.anchor,
anchor_in_table: data.anchor_in_table,
}
}
fn adjusted(self, at: usize, removed: usize, added: usize) -> Self {
Stand {
position: adjust_offset(self.position, at, removed, added),
anchor: adjust_offset(self.anchor, at, removed, added),
anchor_in_table: self
.anchor_in_table
.map(|origin| adjust_offset(origin, at, removed, added)),
}
}
fn mapped_back(self, splices: &[Splice]) -> Self {
let (low, high) = if self.position <= self.anchor {
(&self.position, &self.anchor)
} else {
(&self.anchor, &self.position)
};
let low_back = map_back_through(splices, *low, RangeEnd::Start);
let high_back = if high == low {
low_back
} else {
map_back_through(splices, *high, RangeEnd::End)
};
let (position, anchor) = if self.position <= self.anchor {
(low_back, high_back)
} else {
(high_back, low_back)
};
Stand {
position,
anchor,
anchor_in_table: self
.anchor_in_table
.map(|origin| map_back_through(splices, origin, RangeEnd::Start)),
}
}
}
#[derive(Debug)]
struct Rider {
cursor: Weak<Mutex<CursorData>>,
stood: Stand,
expected: Stand,
cells: Option<crate::flow::CellRange>,
whole_text: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum RangeEnd {
Start,
End,
}
fn unsplice(position: usize, splice: Splice, end: RangeEnd) -> usize {
let Splice { at, removed, added } = splice;
if position < at {
position
} else if position == at {
if added == 0 && end == RangeEnd::Start {
at + removed
} else {
at
}
} else if position <= at + added {
at + removed
} else {
position - added + removed
}
}
fn map_back_through(splices: &[Splice], position: usize, end: RangeEnd) -> usize {
splices
.iter()
.rev()
.fold(position, |p, splice| unsplice(p, *splice, end))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TransientLayerId(u64);
impl TransientLayerId {
fn next() -> Self {
static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
TransientLayerId(NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed))
}
}
#[derive(Debug)]
pub(crate) struct TransientLayer {
id: TransientLayerId,
steps: Vec<Splice>,
splices: Vec<Splice>,
span: Option<Span>,
scattered: bool,
riders: Vec<Rider>,
}
impl TransientLayer {
pub(crate) fn over(cursors: &[Weak<Mutex<CursorData>>]) -> Self {
let riders = cursors
.iter()
.filter_map(|weak| {
let cursor = weak.upgrade()?;
let data = cursor.lock();
let stood = Stand::of(&data);
Some(Rider {
cursor: weak.clone(),
stood,
expected: stood,
cells: data.cell_selection_override.clone(),
whole_text: data.whole_text_selected,
})
})
.collect();
TransientLayer {
id: TransientLayerId::next(),
steps: Vec::new(),
splices: Vec::new(),
span: None,
scattered: false,
riders,
}
}
pub(crate) fn record(&mut self, at: usize, removed: usize, added: usize) {
if removed == 0 && added == 0 {
return;
}
let splice = Splice { at, removed, added };
self.steps.push(splice);
match self.splices.last().and_then(|last| last.then(splice)) {
Some(composed) => *self.splices.last_mut().expect("there is a last") = composed,
None => self.splices.push(splice),
}
for rider in &mut self.riders {
rider.expected = rider.expected.adjusted(at, removed, added);
}
self.span = Some(match self.span {
None => Span {
start: at,
end: at + added,
recorded_end: at + removed,
},
Some(span) => {
if at > span.end || at + removed < span.start {
self.scattered = true;
}
let start = span.start.min(at);
let end_before = span.end.max(at + removed);
let recorded_len = (span.recorded_end - span.start)
+ (span.start - start)
+ (end_before - span.end);
Span {
start,
end: end_before - removed + added,
recorded_end: start + recorded_len,
}
}
});
}
fn stand_after_revert(&self, cursor: &Weak<Mutex<CursorData>>, now: Stand) -> Stand {
match self.carried(cursor, now) {
Some(rider) => rider.stood,
None => now.mapped_back(&self.splices),
}
}
fn carried(&self, cursor: &Weak<Mutex<CursorData>>, now: Stand) -> Option<&Rider> {
self.riders
.iter()
.find(|rider| Weak::ptr_eq(&rider.cursor, cursor) && rider.expected == now)
}
pub(crate) fn map_range_back(&self, start: usize, end: usize) -> (usize, usize) {
map_range_through(&self.splices, start, end)
}
pub(crate) fn map_position_forward(&self, recorded: usize) -> usize {
self.map_forward(recorded)
}
fn map_forward(&self, recorded: usize) -> usize {
self.splices.iter().fold(recorded, |position, splice| {
adjust_offset(position, splice.at, splice.removed, splice.added)
})
}
}
#[derive(Debug, Default)]
pub(crate) struct Reverted {
splices: Vec<Splice>,
}
impl Reverted {
pub(crate) fn map_range(&self, start: usize, end: usize) -> (usize, usize) {
map_range_through(&self.splices, start, end)
}
}
fn map_range_through(splices: &[Splice], start: usize, end: usize) -> (usize, usize) {
let (low, high) = (start.min(end), start.max(end));
if low == high {
let at = map_back_through(splices, low, RangeEnd::Start);
return (at, at);
}
let low = map_back_through(splices, low, RangeEnd::Start);
let high = map_back_through(splices, high, RangeEnd::End);
(low, high.max(low))
}
pub(crate) fn map_range_back(
reverted: &Option<Reverted>,
start: usize,
end: usize,
) -> (usize, usize) {
match reverted {
Some(reverted) => reverted.map_range(start, end),
None => (start.min(end), start.max(end)),
}
}
#[must_use = "hold it until the write has run: the revert's events go out with the write's"]
pub(crate) struct Settled {
doc: Option<Arc<Mutex<TextDocumentInner>>>,
}
impl Drop for Settled {
fn drop(&mut self) {
if let Some(doc) = self.doc.take() {
let queued = doc.lock().take_queued_events();
crate::inner::dispatch_queued_events(queued);
}
}
}
impl TextDocumentInner {
pub(crate) fn revert_transient_edits(&mut self) -> Option<Reverted> {
let layer = self.transient.take()?;
let Ok(reverted) = self.ctx.db_context.get_store().revert_transient_edits() else {
self.transient = Some(layer);
debug_assert!(
false,
"the store refused a revert under the document's lock"
);
return None;
};
debug_assert!(
reverted || layer.steps.is_empty(),
"the document held transient edits that its store did not"
);
self.prune_dead_cursors();
for weak in &self.cursors {
let Some(cursor) = weak.upgrade() else {
continue;
};
let mut data = cursor.lock();
let now = Stand::of(&data);
let back = layer.stand_after_revert(weak, now);
data.position = back.position;
data.anchor = back.anchor;
data.anchor_in_table = back.anchor_in_table;
let carried = layer.carried(weak, now);
data.cell_selection_override = carried.and_then(|rider| rider.cells.clone());
data.whole_text_selected = carried.is_some_and(|rider| rider.whole_text);
}
self.invalidate_text_cache();
if let Some(span) = layer.span {
let blocks_affected = self.blocks_between(span.start, span.recorded_end);
if blocks_affected > 1 {
self.rehighlight_all();
} else {
self.rehighlight_affected(span.start);
}
self.queue_event(DocumentEvent::ContentsChanged {
position: span.start,
chars_removed: span.end - span.start,
chars_added: span.recorded_end - span.start,
blocks_affected,
});
}
self.check_block_count_changed();
self.check_flow_changed();
Some(Reverted {
splices: layer.splices,
})
}
fn blocks_between(&self, start: usize, end: usize) -> usize {
let number = |position: usize| {
frontend::commands::document_inspection_commands::get_block_at_position(
&self.ctx,
&frontend::document_inspection::GetBlockAtPositionDto {
position: position as i64,
},
)
.ok()
.map(|info| info.block_number)
};
match (number(start), number(end.saturating_sub(1).max(start))) {
(Some(first), Some(last)) if last > first => (last - first) as usize + 1,
_ => 1,
}
}
fn announce_kept_changes(&mut self, changes_before: usize, events_before: usize) {
let announced = self
.pending_events
.get(events_before..)
.is_some_and(|events| {
events
.iter()
.any(|event| matches!(event, DocumentEvent::ContentsChanged { .. }))
});
let kept: Vec<Splice> = self
.transient
.as_ref()
.map(|layer| layer.steps[changes_before..].to_vec())
.unwrap_or_default();
self.invalidate_text_cache();
if !announced {
for splice in &kept {
let blocks_affected = self.blocks_between(splice.at, splice.at + splice.added);
self.queue_event(DocumentEvent::ContentsChanged {
position: splice.at,
chars_removed: splice.removed,
chars_added: splice.added,
blocks_affected,
});
}
}
if !kept.is_empty() {
self.check_block_count_changed();
self.check_flow_changed();
}
}
pub(crate) fn read_recorded<R>(&mut self, read: impl FnOnce(&TextDocumentInner) -> R) -> R {
let recorded = self
.transient
.as_ref()
.and_then(|_| self.ctx.db_context.get_store().recorded_snapshot());
let Some(recorded) = recorded else {
return read(self);
};
let mut ctx = self.ctx.clone();
ctx.db_context =
common::database::db_context::DbContext::new().expect("an empty store is always made");
ctx.db_context.get_store().restore(&recorded);
let live = std::mem::replace(&mut self.ctx, ctx);
self.reading_recorded = true;
struct Restore<'a> {
inner: &'a mut TextDocumentInner,
live: Option<frontend::AppContext>,
}
impl Drop for Restore<'_> {
fn drop(&mut self) {
if let Some(live) = self.live.take() {
self.inner.ctx = live;
}
self.inner.reading_recorded = false;
}
}
let restore = Restore {
inner: self,
live: Some(live),
};
read(restore.inner)
}
pub(crate) fn recorded_reading(&self) -> Option<&TransientLayer> {
self.transient.as_ref().filter(|_| self.reading_recorded)
}
fn is_loading_in_place(&self) -> bool {
if self.history_resets.is_empty() {
return false;
}
let operations = self.ctx.long_operation_manager.lock();
self.history_resets
.keys()
.any(|id| operations.is_operation_finished(id) == Some(false))
}
}
pub(crate) fn settle(doc: &Arc<Mutex<TextDocumentInner>>) -> Settled {
let reverted = doc.lock().revert_transient_edits().is_some();
Settled {
doc: reverted.then(|| Arc::clone(doc)),
}
}
impl TextCursor {
pub(crate) fn settle_transient_edits(&self) -> Settled {
settle(&self.doc)
}
fn edit_transiently<R>(
&self,
edit: impl FnOnce(&mut TextDocumentInner) -> Result<(R, QueuedEvents)>,
) -> Result<R> {
let (value, queued) = {
let mut inner = self.doc.lock();
if inner.is_loading_in_place() {
return Err(DocumentError::TransientEdits(
crate::TransientRefusal::LoadInPlace,
));
}
let store = Arc::clone(inner.ctx.db_context.get_store());
let write = store
.begin_transient_write()
.map_err(|refused| DocumentError::TransientEdits(refused.into()))?;
let opened = write.opens();
if opened {
let layer = TransientLayer::over(&inner.cursors);
inner.transient = Some(layer);
}
let changes =
|inner: &TextDocumentInner| inner.transient.as_ref().map_or(0, |l| l.steps.len());
let changes_before = changes(&inner);
let events_before = inner.pending_events.len();
let outcome =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| edit(&mut inner)));
if changes(&inner) > changes_before {
write.keep();
if outcome.is_err() {
inner.announce_kept_changes(changes_before, events_before);
}
} else {
drop(write);
if opened {
inner.transient = None;
}
inner.invalidate_text_cache();
}
match outcome {
Ok(Ok(done)) => done,
Ok(Err(error)) => return Err(error),
Err(panic) => {
let queued = inner.take_queued_events();
drop(inner);
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
crate::inner::dispatch_queued_events(queued)
}));
std::panic::resume_unwind(panic);
}
}
};
crate::inner::dispatch_queued_events(queued);
Ok(value)
}
pub fn insert_text_transient(&self, text: &str) -> Result<()> {
self.edit_transiently(|inner| {
let (pos, anchor) = self.read_cursor();
let queued = self.insert_text_locked(
inner,
pos,
anchor,
text,
ReplaceFormatPolicy::default(),
InsertionOrigin::Unspecified,
Recording::Transient,
)?;
Ok(((), queued))
})
}
pub fn insert_formatted_text_transient(&self, text: &str, format: &TextFormat) -> Result<()> {
self.edit_transiently(|inner| {
let (pos, anchor) = self.read_cursor();
let queued = self.insert_formatted_text_locked(
inner,
pos,
anchor,
text,
format,
InsertionOrigin::Unspecified,
Recording::Transient,
)?;
Ok(((), queued))
})
}
pub fn insert_text_transient_merged(&self, text: &str, format: &TextFormat) -> Result<()> {
self.edit_transiently(|inner| {
let (pos, anchor) = self.read_cursor();
let queued = self.insert_text_merging_locked(
inner,
pos,
anchor,
text,
ReplaceFormatPolicy::default(),
Some(format),
InsertionOrigin::Unspecified,
Recording::Transient,
)?;
Ok(((), queued))
})
}
pub fn remove_selected_text_transient(&self) -> Result<String> {
self.edit_transiently(|inner| {
let (pos, anchor) = self.read_cursor();
if pos == anchor {
return Ok((String::new(), inner.take_queued_events()));
}
self.remove_locked(inner, pos, anchor, Recording::Transient)
})
}
pub fn commit_transient_text(&self, text: &str) -> Result<()> {
self.commit_transient_text_with_origin(text, InsertionOrigin::Unspecified)
}
pub fn commit_transient_text_with_origin(
&self,
text: &str,
origin: InsertionOrigin,
) -> Result<()> {
let (result, rest) = {
let mut inner = self.doc.lock();
let range = match inner.transient.as_ref() {
Some(layer) if layer.scattered => {
return Err(DocumentError::TransientEdits(
crate::TransientRefusal::CommitInSeveralPlaces,
));
}
Some(TransientLayer {
span: Some(span), ..
}) => Some((span.start, span.recorded_end)),
_ => None,
};
inner.revert_transient_edits();
let (start, end) = range.unwrap_or_else(|| self.read_cursor());
let records = !text.is_empty() || start != end;
let stack = Some(inner.stack_id);
if records {
undo_redo_commands::seal_head(&inner.ctx, stack);
}
let result = if !text.is_empty() {
self.insert_text_locked(
&mut inner,
start,
end,
text,
ReplaceFormatPolicy::PreserveIfFullyCovered,
origin,
Recording::History,
)
} else if start != end {
self.remove_locked(&mut inner, start, end, Recording::History)
.map(|(_, queued)| queued)
} else {
Ok(Vec::new())
};
if records {
undo_redo_commands::seal_head(&inner.ctx, stack);
}
(result, inner.take_queued_events())
};
match result {
Ok(mut queued) => {
queued.extend(rest);
crate::inner::dispatch_queued_events(queued);
Ok(())
}
Err(error) => {
crate::inner::dispatch_queued_events(rest);
Err(error)
}
}
}
pub fn recorded_position(&self) -> usize {
self.recorded_stand().position
}
pub fn recorded_anchor(&self) -> usize {
self.recorded_stand().anchor
}
fn recorded_stand(&self) -> Stand {
let inner = self.doc.lock();
let now = Stand::of(&self.data.lock());
match inner.transient.as_ref() {
Some(layer) => layer.stand_after_revert(&Arc::downgrade(&self.data), now),
None => now,
}
}
}
impl TextDocument {
pub(crate) fn settle_transient_edits(&self) -> Settled {
settle(&self.inner)
}
pub fn has_transient_edits(&self) -> bool {
self.inner.lock().transient.is_some()
}
pub fn transient_layer(&self) -> Option<TransientLayerId> {
self.inner.lock().transient.as_ref().map(|layer| layer.id)
}
pub fn transient_range(&self) -> Option<Range<usize>> {
let inner = self.inner.lock();
let span = inner.transient.as_ref()?.span?;
Some(span.start..span.end)
}
pub fn revert_transient_edits(&self) -> bool {
let queued = {
let mut inner = self.inner.lock();
if inner.revert_transient_edits().is_none() {
return false;
}
inner.take_queued_events()
};
crate::inner::dispatch_queued_events(queued);
true
}
pub fn snapshot_recorded_flow_masked(
&self,
mask: &crate::highlight::HighlightMask,
) -> crate::flow::FlowSnapshot {
self.inner
.lock()
.read_recorded(|inner| crate::document::flow_snapshot_of(inner, mask, false))
}
pub fn snapshot_recorded_flow_masked_no_paint(
&self,
mask: &crate::highlight::HighlightMask,
) -> crate::flow::FlowSnapshot {
self.inner
.lock()
.read_recorded(|inner| crate::document::flow_snapshot_of(inner, mask, true))
}
pub fn snapshot_recorded_block_at_position_masked(
&self,
position: usize,
mask: &crate::highlight::HighlightMask,
) -> Option<crate::flow::BlockSnapshot> {
self.inner
.lock()
.read_recorded(|inner| crate::document::block_snapshot_at(inner, position, mask))
}
pub fn recorded_position(&self, position: usize) -> usize {
match self.inner.lock().transient.as_ref() {
Some(layer) => map_back_through(&layer.splices, position, RangeEnd::Start),
None => position,
}
}
pub fn position_from_recorded(&self, recorded: usize) -> usize {
match self.inner.lock().transient.as_ref() {
Some(layer) => layer.map_forward(recorded),
None => recorded,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn layer(splices: &[(usize, usize, usize)]) -> TransientLayer {
let mut layer = TransientLayer::over(&[]);
for &(at, removed, added) in splices {
layer.record(at, removed, added);
}
layer
}
#[test]
fn a_composition_replaced_at_every_update_is_one_span_over_nothing_recorded() {
let layer = layer(&[(3, 0, 1), (3, 1, 2), (3, 2, 3), (3, 3, 5)]);
assert_eq!(
layer.span,
Some(Span {
start: 3,
end: 8,
recorded_end: 3
})
);
assert!(!layer.scattered);
}
#[test]
fn a_removed_syllable_shown_converted_is_one_span_over_the_syllable() {
let layer = layer(&[(7, 1, 0), (7, 0, 1)]);
assert_eq!(
layer.span,
Some(Span {
start: 7,
end: 8,
recorded_end: 8
})
);
assert!(!layer.scattered);
}
#[test]
fn an_edit_touching_the_span_from_before_extends_it() {
let layer = layer(&[(5, 0, 3), (3, 2, 0)]);
assert_eq!(
layer.span,
Some(Span {
start: 3,
end: 6,
recorded_end: 5
})
);
assert!(!layer.scattered);
}
#[test]
fn an_edit_away_from_the_span_scatters_the_layer() {
let layer = layer(&[(3, 0, 2), (10, 0, 1)]);
assert!(layer.scattered);
assert_eq!(
layer.span,
Some(Span {
start: 3,
end: 11,
recorded_end: 8
})
);
}
#[test]
fn a_removal_then_an_insertion_in_its_place_is_one_replacement() {
let layer = layer(&[(2, 1, 0), (2, 0, 1)]);
assert_eq!(
layer.splices,
[Splice {
at: 2,
removed: 1,
added: 1
}]
);
assert_eq!(layer.steps.len(), 2);
let reverted = Reverted {
splices: layer.splices.clone(),
};
assert_eq!(
reverted.map_range(2, 3),
(2, 3),
"the candidate is the syllable"
);
assert_eq!(layer.map_forward(3), 3);
}
#[test]
fn changes_that_touch_compose_and_others_do_not() {
let composed = |a: (usize, usize, usize), b: (usize, usize, usize)| {
let splice = |(at, removed, added)| Splice { at, removed, added };
splice(a)
.then(splice(b))
.map(|s| (s.at, s.removed, s.added))
};
assert_eq!(composed((3, 0, 1), (3, 1, 2)), Some((3, 0, 2)));
assert_eq!(composed((5, 0, 3), (3, 2, 0)), Some((3, 2, 3)));
assert_eq!(composed((2, 0, 2), (3, 3, 0)), Some((2, 2, 1)));
assert_eq!(composed((2, 0, 2), (4, 2, 0)), Some((2, 2, 2)));
assert_eq!(composed((2, 0, 2), (5, 0, 1)), None);
assert_eq!(composed((5, 0, 2), (1, 2, 0)), None);
}
#[test]
fn a_change_of_nothing_is_not_recorded() {
let layer = layer(&[(4, 0, 0)]);
assert!(layer.splices.is_empty());
assert_eq!(layer.span, None);
}
#[test]
fn mapping_back_undoes_every_change_in_reverse() {
let reverted = Reverted {
splices: vec![
Splice {
at: 3,
removed: 0,
added: 1,
},
Splice {
at: 3,
removed: 1,
added: 5,
},
],
};
for end in [RangeEnd::Start, RangeEnd::End] {
let map = |position| map_back_through(&reverted.splices, position, end);
assert_eq!(map(2), 2);
assert_eq!(map(5), 3);
assert_eq!(map(8), 3);
assert_eq!(map(12), 7);
}
}
#[test]
fn a_range_starting_where_text_was_removed_starts_after_it_again() {
let reverted = Reverted {
splices: vec![Splice {
at: 2,
removed: 2,
added: 0,
}],
};
assert_eq!(reverted.map_range(2, 3), (4, 5));
assert_eq!(reverted.map_range(0, 2), (0, 2));
assert_eq!(reverted.map_range(1, 3), (1, 5));
}
#[test]
fn a_recorded_edit_finding_a_layer_keeps_the_edit_block_whole() {
let doc = TextDocument::new();
doc.set_plain_text("hello world").unwrap();
doc.clear_undo_redo();
let cursor = doc.cursor_at(0);
cursor.begin_edit_block();
cursor.insert_text("A").unwrap();
doc.cursor_at(3).insert_text_transient("x").unwrap();
let refused = {
let mut inner = doc.inner.lock();
cursor.insert_text_locked(
&mut inner,
7,
12,
"b",
ReplaceFormatPolicy::default(),
InsertionOrigin::Unspecified,
Recording::History,
)
};
assert!(matches!(
refused,
Err(DocumentError::TransientEdits(
crate::TransientRefusal::LayerOutstanding
))
));
cursor.end_edit_block();
doc.revert_transient_edits();
assert_eq!(doc.to_plain_text().unwrap(), "Ahello world");
doc.undo().unwrap();
assert_eq!(doc.to_plain_text().unwrap(), "hello world");
assert!(!doc.can_undo());
}
#[test]
fn a_transient_edit_over_an_open_write_is_refused_by_the_store() {
let doc = TextDocument::new();
doc.set_plain_text("abc").unwrap();
let db = doc.inner.lock().ctx.db_context.clone();
let transaction =
common::database::transactions::Transaction::begin_write_transaction(&db).unwrap();
let refused = doc.cursor_at(1).insert_text_transient("n");
assert!(matches!(
refused,
Err(DocumentError::TransientEdits(
crate::TransientRefusal::WriteInProgress
))
));
assert!(!doc.has_transient_edits());
assert_eq!(doc.to_plain_text().unwrap(), "abc");
drop(transaction);
doc.cursor_at(1).insert_text_transient("n").unwrap();
assert_eq!(doc.to_plain_text().unwrap(), "anbc");
}
#[test]
fn a_range_that_held_only_transient_text_comes_back_empty() {
let reverted = Reverted {
splices: vec![Splice {
at: 5,
removed: 0,
added: 3,
}],
};
assert_eq!(reverted.map_range(5, 8), (5, 5));
assert_eq!(reverted.map_range(6, 7), (5, 5));
}
}