use crate::database::Store;
use crate::database::block_offset_index::OffsetMarker;
use crate::entities::Block;
use crate::format_runs::{
FootnoteRefAnchor, FormatRun, FormatRunError, ImageAnchor, ReplaceFormatPolicy,
check_well_formed, logical_offset_to_byte, shift_footnote_refs_for_delete,
shift_footnote_refs_for_insert, shift_images_for_delete, shift_images_for_insert,
shift_runs_for_replace,
};
use crate::types::EntityId;
use std::collections::HashMap;
pub fn block_content_via_store(block: &Block, store: &Store) -> String {
let offsets = store.block_offsets.read();
let marker = OffsetMarker::Block(block.id);
let Some((bs, be, has_successor)) = offsets.range_with_successor(marker) else {
return String::new();
};
let content_end = if has_successor && be > bs { be - 1 } else { be };
drop(offsets);
let rope = store.rope.read();
rope.byte_slice(bs as usize..content_end as usize)
.to_string()
}
pub fn block_char_length(block: &Block, store: &Store) -> i64 {
let offsets = store.block_offsets.read();
let marker = OffsetMarker::Block(block.id);
let Some((bs, be, has_successor)) = offsets.range_with_successor(marker) else {
return 0;
};
let content_end_bytes = if has_successor && be > bs { be - 1 } else { be };
drop(offsets);
let rope = store.rope.read();
let char_start = rope.byte_to_char(bs as usize);
let char_end = rope.byte_to_char(content_end_bytes as usize);
(char_end - char_start) as i64
}
pub fn block_document_position(block: &Block, store: &Store) -> i64 {
let offsets = store.block_offsets.read();
let Some((byte_start, _)) = offsets.range_of_block(block.id) else {
return block.document_position;
};
drop(offsets);
let rope = store.rope.read();
rope.byte_to_char(byte_start as usize) as i64
}
pub fn refresh_positions_from_rope<'a>(
store: &Store,
slots: impl IntoIterator<Item = (EntityId, &'a mut i64)>,
) {
if !rope_positions_match_flow(store) {
return;
}
let offsets = store.block_offsets.read();
let rope = store.rope.read();
for (block_id, slot) in slots {
if let Some((byte_start, _)) = offsets.range_of_block(block_id) {
*slot = rope.byte_to_char(byte_start as usize) as i64;
}
}
}
pub fn refresh_block_positions(blocks: &mut [Block], store: &Store) {
refresh_positions_from_rope(
store,
blocks.iter_mut().map(|b| (b.id, &mut b.document_position)),
);
}
pub fn rope_positions_match_flow(store: &Store) -> bool {
let offsets = store.block_offsets.read();
let indexed_block_count = offsets.len() - offsets.table_anchor_count();
drop(offsets);
let total_block_count = store.blocks.read().len();
indexed_block_count == total_block_count
}
pub fn main_text_end(store: &Store) -> Option<i64> {
if !rope_positions_match_flow(store) {
return None;
}
let main_frame = store
.documents
.read()
.values()
.next()
.and_then(|document| document.frames.first().copied())?;
let last = {
let tables = store.tables.read();
let cells = store.table_cells.read();
let frames = store.frames.read();
last_flow_entry(main_frame, &tables, &cells, &frames)?
};
let offsets = store.block_offsets.read();
let last_of_text = offsets.position_of(last)?;
looked_at(1);
let next_start = offsets.entries.get(last_of_text + 1)?.1;
drop(offsets);
let end_byte = next_start.saturating_sub(1) as usize;
Some(store.rope.read().byte_to_char(end_byte) as i64)
}
fn last_flow_entry(
frame_id: EntityId,
tables: &im::HashMap<EntityId, crate::entities::Table>,
cells: &im::HashMap<EntityId, crate::entities::TableCell>,
frames: &im::HashMap<EntityId, crate::entities::Frame>,
) -> Option<OffsetMarker> {
let mut stack: Vec<(EntityId, usize)> =
vec![(frame_id, frames.get(&frame_id)?.child_order.len())];
let mut seen: std::collections::HashSet<EntityId> = std::collections::HashSet::new();
seen.insert(frame_id);
while let Some((id, remaining)) = stack.pop() {
looked_at(1);
let Some(entry) = remaining
.checked_sub(1)
.and_then(|at| frames.get(&id)?.child_order.get(at).copied())
else {
continue;
};
stack.push((id, remaining - 1));
if entry > 0 {
return Some(OffsetMarker::Block(entry as EntityId));
}
let sub_id = entry.unsigned_abs() as EntityId;
let Some(sub) = frames.get(&sub_id) else {
continue;
};
if !seen.insert(sub_id) {
continue;
}
match sub.table {
Some(table_id) => {
let mut ordered: Vec<OffsetMarker> = Vec::new();
table_reading_order(table_id, tables, cells, frames, &mut ordered);
looked_at(ordered.len());
return ordered.last().copied();
}
None => stack.push((sub_id, sub.child_order.len())),
}
}
None
}
fn looked_at(count: usize) {
#[cfg(test)]
tests::LOOKED_AT.with(|looked| looked.set(looked.get() + count));
#[cfg(not(test))]
let _ = count;
}
pub fn find_block_at_char_position(store: &Store, position: i64) -> Option<(EntityId, i64, i64)> {
let offsets = store.block_offsets.read();
let indexed_block_count = offsets.entries.iter().filter(|(m, _)| m.is_block()).count();
let total_block_count = store.blocks.read().len();
if indexed_block_count != total_block_count {
return None;
}
drop(offsets);
let rope = store.rope.read();
let total_chars = rope.len_chars() as i64;
let pos_clamped = position.clamp(0, total_chars);
let abs_byte = rope.char_to_byte(pos_clamped as usize);
drop(rope);
let offsets = store.block_offsets.read();
let block_id = offsets.marker_at_byte(abs_byte as u32)?.as_block()?;
let (bs, be, has_successor) = offsets.range_with_successor(OffsetMarker::Block(block_id))?;
let content_end = if has_successor && be > bs { be - 1 } else { be };
drop(offsets);
let rope = store.rope.read();
let block_char_start = rope.byte_to_char(bs as usize) as i64;
let byte_for_char = std::cmp::min(abs_byte, content_end as usize);
let abs_char = rope.byte_to_char(byte_for_char) as i64;
let char_in_block = abs_char - block_char_start;
let _ = has_successor;
Some((block_id, char_in_block, block_char_start))
}
pub fn block_char_to_byte_in_block(
store: &Store,
block_id: EntityId,
char_offset: usize,
) -> (u32, usize) {
let offsets = store.block_offsets.read();
let marker = OffsetMarker::Block(block_id);
let Some((bs, be, has_successor)) = offsets.range_with_successor(marker) else {
return (0, 0);
};
let content_end_bytes = if has_successor && be > bs { be - 1 } else { be };
let content_byte_len = (content_end_bytes - bs) as usize;
drop(offsets);
let rope = store.rope.read();
let block_char_start = rope.byte_to_char(bs as usize);
let block_char_end = rope.byte_to_char(content_end_bytes as usize);
let block_char_len = block_char_end - block_char_start;
let clamped = std::cmp::min(char_offset, block_char_len);
let abs_byte = rope.char_to_byte(block_char_start + clamped);
let byte_in_block = (abs_byte - bs as usize) as u32;
(byte_in_block, content_byte_len)
}
pub fn rope_flat_text_if_simple(store: &Store, top_frame_count: usize) -> Option<String> {
if top_frame_count != 1 {
return None;
}
let offsets = store.block_offsets.read();
let has_table = offsets
.entries
.iter()
.any(|(m, _)| matches!(m, OffsetMarker::TableAnchor(_)));
if has_table {
return None;
}
drop(offsets);
Some(store.rope.read().to_string())
}
pub fn rope_full_text_if_flow_matches(store: &Store) -> Option<String> {
rope_positions_match_flow(store).then(|| store.rope.read().to_string())
}
pub fn rope_reset(store: &Store) {
*store.rope.write() = ropey::Rope::new();
*store.block_offsets.write() = crate::database::block_offset_index::BlockOffsetIndex::new();
}
pub fn rope_append_block(store: &Store, block_id: EntityId, text: &str) -> u32 {
let mut rope = store.rope.write();
let byte_start = rope.len_bytes() as u32;
let char_end = rope.len_chars();
rope.insert(char_end, text);
let new_total = rope.len_bytes() as u32;
drop(rope);
let mut offsets = store.block_offsets.write();
offsets.push_block(block_id, byte_start);
offsets.set_total_bytes(new_total);
byte_start
}
pub fn rope_insert_block_at(store: &Store, byte_pos: u32, block_id: EntityId, text: &str) {
let delta = (1 + text.len()) as i32;
let new_entry_vec_pos = {
let offsets = store.block_offsets.read();
offsets
.entries
.iter()
.position(|(_, bs)| *bs > byte_pos)
.unwrap_or(offsets.entries.len())
};
{
let mut rope = store.rope.write();
let char_idx = rope.byte_to_char(byte_pos as usize);
let mut combined = String::with_capacity(1 + text.len());
combined.push('\n');
combined.push_str(text);
rope.insert(char_idx, &combined);
}
let mut offsets = store.block_offsets.write();
offsets.shift_after(byte_pos + 1, delta);
offsets.insert_at(
new_entry_vec_pos,
OffsetMarker::Block(block_id),
byte_pos + 1,
);
}
pub fn top_level_frame_end_byte(store: &Store, frame_id: EntityId) -> u32 {
let top_id = {
let frames = store.frames.read();
let mut current = frame_id;
loop {
let Some(f) = frames.get(¤t) else {
return 0;
};
match f.parent_frame {
None => break current,
Some(p) => current = p,
}
}
};
let (_min, max) = compute_frame_byte_range_recursive(store, top_id);
max
}
pub fn rope_append_empty_block(store: &Store, block_id: EntityId) -> u32 {
let was_empty = store.rope.read().len_bytes() == 0;
if !was_empty {
rope_insert_block_boundary(store);
}
let pos = store.rope.read().len_bytes() as u32;
let mut offsets = store.block_offsets.write();
offsets.push_block(block_id, pos);
offsets.set_total_bytes(pos);
pos
}
pub fn rope_insert_empty_block_first(store: &Store, block_id: EntityId) {
let mut offsets = store.block_offsets.write();
if !offsets.is_empty() {
{
let mut rope = store.rope.write();
rope.insert(0, "\n");
}
offsets.shift_after(0, 1);
}
offsets.insert_at(0, OffsetMarker::Block(block_id), 0);
}
pub fn rope_insert_block_boundary(store: &Store) {
let mut rope = store.rope.write();
let char_end = rope.len_chars();
rope.insert(char_end, "\n");
let new_total = rope.len_bytes() as u32;
drop(rope);
store.block_offsets.write().set_total_bytes(new_total);
}
pub fn rope_insert_in_block(
store: &Store,
block_id: EntityId,
byte_offset_in_block: u32,
text: &str,
) {
let inserted_bytes = text.len() as u32;
if inserted_bytes == 0 {
return;
}
let block_byte_start = {
let offsets = store.block_offsets.read();
let Some((start, _end)) = offsets.range_of_block(block_id) else {
return;
};
start
};
let rope_byte = block_byte_start + byte_offset_in_block;
{
let mut rope = store.rope.write();
let char_idx = rope.byte_to_char(rope_byte as usize);
rope.insert(char_idx, text);
}
store
.block_offsets
.write()
.shift_after(block_byte_start + 1, inserted_bytes as i32);
}
pub fn rope_split_block(
store: &Store,
current_block_id: EntityId,
byte_offset_in_block: u32,
new_block_id: EntityId,
) {
let current_marker = OffsetMarker::Block(current_block_id);
let (block_start, current_idx) = {
let offsets = store.block_offsets.read();
let Some((start, _end)) = offsets.range_of(current_marker) else {
return;
};
let idx = offsets
.entries
.iter()
.position(|(m, _)| *m == current_marker)
.unwrap();
(start, idx)
};
let split_byte = block_start + byte_offset_in_block;
{
let mut rope = store.rope.write();
let char_idx = rope.byte_to_char(split_byte as usize);
rope.insert(char_idx, "\n");
}
store.block_offsets.write().shift_after(split_byte + 1, 1);
store.block_offsets.write().insert_at(
current_idx + 1,
OffsetMarker::Block(new_block_id),
split_byte + 1,
);
}
pub fn rope_split_block_into(
store: &Store,
current_block_id: EntityId,
byte_offset_in_block: u32,
blocks: &[(EntityId, &str)],
) {
let current_marker = OffsetMarker::Block(current_block_id);
let (block_start, current_idx) = {
let offsets = store.block_offsets.read();
let (Some((start, _end)), Some(idx)) = (
offsets.range_of(current_marker),
offsets.position_of(current_marker),
) else {
return;
};
(start, idx)
};
rope_insert_marker_run(
store,
block_start + byte_offset_in_block,
current_idx + 1,
blocks
.iter()
.map(|(block_id, text)| (OffsetMarker::Block(*block_id), *text)),
);
}
pub fn rope_insert_blocks_at(store: &Store, byte_pos: u32, blocks: &[(EntityId, &str)]) -> u32 {
let vec_pos = {
let offsets = store.block_offsets.read();
offsets
.entries
.iter()
.position(|(_, bs)| *bs > byte_pos)
.unwrap_or(offsets.entries.len())
};
rope_insert_marker_run(
store,
byte_pos,
vec_pos,
blocks
.iter()
.map(|(block_id, text)| (OffsetMarker::Block(*block_id), *text)),
)
}
pub fn rope_insert_run_after(
store: &Store,
after: OffsetMarker,
run: &[(OffsetMarker, &str)],
) -> bool {
let (content_end, position) = {
let offsets = store.block_offsets.read();
let (Some((start, end, has_successor)), Some(position)) = (
offsets.range_with_successor(after),
offsets.position_of(after),
) else {
return false;
};
let content_end = if has_successor && end > start {
end - 1
} else {
end
};
(content_end, position)
};
rope_insert_marker_run(store, content_end, position + 1, run.iter().copied());
true
}
pub fn rope_insert_run_before(
store: &Store,
before: OffsetMarker,
run: &[(OffsetMarker, &str)],
) -> bool {
let previous = {
let offsets = store.block_offsets.read();
let Some(position) = offsets.position_of(before) else {
return false;
};
position
.checked_sub(1)
.and_then(|at| offsets.entries.get(at))
.map(|(marker, _)| *marker)
};
if let Some(previous) = previous {
return rope_insert_run_after(store, previous, run);
}
if run.is_empty() {
return true;
}
let mut inserted = String::new();
let mut entries = Vec::with_capacity(run.len());
for (marker, text) in run {
entries.push((*marker, inserted.len() as u32));
inserted.push_str(text);
inserted.push('\n');
}
store.rope.write().insert(0, &inserted);
let mut offsets = store.block_offsets.write();
offsets.shift_after(0, inserted.len() as i32);
offsets.insert_run_at(0, &entries);
true
}
fn rope_insert_marker_run<'a>(
store: &Store,
byte_pos: u32,
vec_pos: usize,
markers: impl IntoIterator<Item = (OffsetMarker, &'a str)>,
) -> u32 {
let mut inserted = String::new();
let mut run = Vec::new();
for (marker, text) in markers {
inserted.push('\n');
run.push((marker, byte_pos + inserted.len() as u32));
inserted.push_str(text);
}
if run.is_empty() {
return byte_pos;
}
{
let mut rope = store.rope.write();
let char_idx = rope.byte_to_char(byte_pos as usize);
rope.insert(char_idx, &inserted);
}
let mut offsets = store.block_offsets.write();
offsets.shift_after(byte_pos + 1, inserted.len() as i32);
offsets.insert_run_at(vec_pos, &run);
byte_pos + inserted.len() as u32
}
pub fn rope_place_new_cell_blocks(store: &Store, table_id: EntityId, new_blocks: &[EntityId]) {
if new_blocks.is_empty() {
return;
}
let new: std::collections::HashSet<EntityId> = new_blocks.iter().copied().collect();
let mut ordered: Vec<OffsetMarker> = Vec::new();
{
let tables = store.tables.read();
let cells = store.table_cells.read();
let frames = store.frames.read();
table_reading_order(table_id, &tables, &cells, &frames, &mut ordered);
}
let mut after = OffsetMarker::TableAnchor(table_id);
let mut run: Vec<(OffsetMarker, &str)> = Vec::new();
for marker in ordered {
if matches!(marker, OffsetMarker::Block(id) if new.contains(&id)) {
run.push((marker, ""));
continue;
}
if !run.is_empty() {
rope_insert_run_after(store, after, &run);
run.clear();
}
after = marker;
}
if !run.is_empty() {
rope_insert_run_after(store, after, &run);
}
}
pub fn rope_restore_table_reading_order(store: &Store, table_id: EntityId) {
let mut ordered: Vec<OffsetMarker> = Vec::new();
{
let tables = store.tables.read();
let cells = store.table_cells.read();
let frames = store.frames.read();
table_reading_order(table_id, &tables, &cells, &frames, &mut ordered);
}
let mut offsets = store.block_offsets.write();
let positions: Option<Vec<usize>> = ordered
.iter()
.map(|marker| offsets.position_of(*marker))
.collect();
let Some(positions) = positions else {
return;
};
if positions.windows(2).all(|pair| pair[0] < pair[1]) {
return;
}
let Some(first) = positions.iter().min().copied() else {
return;
};
let last = first + positions.len() - 1;
let mut sorted = positions.clone();
sorted.sort_unstable();
if sorted
.iter()
.enumerate()
.any(|(i, position)| *position != first + i)
{
return;
}
let total = offsets.total_bytes();
let entries = offsets.entries.clone();
let text_end = |index: usize| -> u32 {
entries
.get(index + 1)
.map_or(total, |(_, next)| next.saturating_sub(1))
};
let span_start = entries[first].1;
let span_end = text_end(last);
let mut rope = store.rope.write();
let char_of = |byte: u32| rope.byte_to_char(byte as usize);
let text_of = |index: usize| -> String {
let (start, end) = (entries[index].1, text_end(index));
rope.slice(char_of(start)..char_of(end)).to_string()
};
let mut rebuilt = String::with_capacity((span_end - span_start) as usize);
let mut run: Vec<(OffsetMarker, u32)> = Vec::with_capacity(positions.len());
for (marker, position) in ordered.iter().zip(&positions) {
if !run.is_empty() {
rebuilt.push('\n');
}
run.push((*marker, span_start + rebuilt.len() as u32));
rebuilt.push_str(&text_of(*position));
}
if rebuilt.len() as u32 != span_end - span_start {
return;
}
let (char_start, char_end) = (char_of(span_start), char_of(span_end));
rope.remove(char_start..char_end);
rope.insert(char_start, &rebuilt);
offsets.reorder_run(first, &run);
}
fn table_reading_order(
table_id: EntityId,
tables: &im::HashMap<EntityId, crate::entities::Table>,
cells: &im::HashMap<EntityId, crate::entities::TableCell>,
frames: &im::HashMap<EntityId, crate::entities::Frame>,
out: &mut Vec<OffsetMarker>,
) {
out.push(OffsetMarker::TableAnchor(table_id));
let Some(table) = tables.get(&table_id) else {
return;
};
let mut table_cells: Vec<_> = table.cells.iter().filter_map(|id| cells.get(id)).collect();
table_cells.sort_by_key(|cell| (cell.row, cell.column));
for cell in table_cells {
if let Some(frame) = cell.cell_frame {
frame_reading_order(frame, tables, cells, frames, out);
}
}
}
pub fn table_block_ids(store: &Store, table_id: EntityId) -> Vec<EntityId> {
let mut ordered: Vec<OffsetMarker> = Vec::new();
{
let tables = store.tables.read();
let cells = store.table_cells.read();
let frames = store.frames.read();
table_reading_order(table_id, &tables, &cells, &frames, &mut ordered);
}
ordered
.into_iter()
.filter_map(OffsetMarker::as_block)
.collect()
}
pub fn rope_insert_run_after_table(
store: &Store,
table_id: EntityId,
run: &[(OffsetMarker, &str)],
) -> bool {
let mut ordered: Vec<OffsetMarker> = Vec::new();
{
let tables = store.tables.read();
let cells = store.table_cells.read();
let frames = store.frames.read();
table_reading_order(table_id, &tables, &cells, &frames, &mut ordered);
}
match ordered.last() {
Some(last) => rope_insert_run_after(store, *last, run),
None => false,
}
}
pub fn outermost_table_around(
store: &Store,
frame_id: EntityId,
) -> Option<(EntityId, EntityId, EntityId)> {
let tables = store.tables.read();
let cells = store.table_cells.read();
let frames = store.frames.read();
let table_of_cell_frame = |frame: EntityId| {
let (cell_id, _) = cells
.iter()
.find(|(_, cell)| cell.cell_frame == Some(frame))?;
tables
.iter()
.find(|(_, table)| table.cells.contains(cell_id))
.map(|(table_id, _)| *table_id)
};
let frame_listing = |frame: EntityId| {
let entry = -(frame as i64);
frames
.iter()
.find(|(_, candidate)| candidate.child_order.contains(&entry))
.map(|(id, _)| *id)
};
let mut found = None;
let mut current = frame_id;
for _ in 0..=frames.len() {
let next = match table_of_cell_frame(current) {
Some(table_id) => {
let Some((anchor_id, _)) = frames
.iter()
.find(|(_, frame)| frame.table == Some(table_id))
else {
break;
};
let Some(parent) = frame_listing(*anchor_id) else {
break;
};
found = Some((table_id, *anchor_id, parent));
parent
}
None => match frame_listing(current) {
Some(parent) => parent,
None => break,
},
};
current = next;
}
found
}
fn frame_reading_order(
frame_id: EntityId,
tables: &im::HashMap<EntityId, crate::entities::Table>,
cells: &im::HashMap<EntityId, crate::entities::TableCell>,
frames: &im::HashMap<EntityId, crate::entities::Frame>,
out: &mut Vec<OffsetMarker>,
) {
let Some(frame) = frames.get(&frame_id) else {
return;
};
for entry in &frame.child_order {
if *entry > 0 {
out.push(OffsetMarker::Block(*entry as EntityId));
} else if *entry < 0 {
let sub_id = (-*entry) as EntityId;
match frames.get(&sub_id).and_then(|sub| sub.table) {
Some(nested) => table_reading_order(nested, tables, cells, frames, out),
None => frame_reading_order(sub_id, tables, cells, frames, out),
}
}
}
}
pub fn rope_merge_block_range(
store: &Store,
start_block_id: EntityId,
byte_so_in_start: u32,
end_block_id: EntityId,
byte_eo_in_end: u32,
) {
let start_marker = OffsetMarker::Block(start_block_id);
let end_marker = OffsetMarker::Block(end_block_id);
let (start_block_byte, end_block_byte, start_idx, end_idx) = {
let offsets = store.block_offsets.read();
let Some((sb, _)) = offsets.range_of(start_marker) else {
return;
};
let Some((eb, _)) = offsets.range_of(end_marker) else {
return;
};
let si = offsets
.entries
.iter()
.position(|(m, _)| *m == start_marker)
.unwrap();
let ei = offsets
.entries
.iter()
.position(|(m, _)| *m == end_marker)
.unwrap();
(sb, eb, si, ei)
};
if end_idx <= start_idx {
return;
}
let delete_start = start_block_byte + byte_so_in_start;
let delete_end = end_block_byte + byte_eo_in_end;
if delete_end <= delete_start {
return;
}
let deleted_bytes = delete_end - delete_start;
{
let mut rope = store.rope.write();
let char_start = rope.byte_to_char(delete_start as usize);
let char_end = rope.byte_to_char(delete_end as usize);
rope.remove(char_start..char_end);
}
{
let mut offsets = store.block_offsets.write();
offsets.drain_inclusive(start_idx + 1, end_idx);
}
store
.block_offsets
.write()
.shift_after(delete_start + 1, -(deleted_bytes as i32));
}
pub fn rope_insert_table_anchor(
store: &Store,
table_id: EntityId,
target_block_id: EntityId,
after: bool,
) {
const SENTINEL: &str = "\u{FFFC}"; const SENTINEL_BYTES: u32 = 3;
let (insert_pos, target_idx, target_is_last) = {
let offsets = store.block_offsets.read();
let target_marker = OffsetMarker::Block(target_block_id);
let Some((start, end)) = offsets.range_of(target_marker) else {
return;
};
let idx = offsets
.entries
.iter()
.position(|(m, _)| *m == target_marker)
.unwrap();
let is_last = idx + 1 == offsets.entries.len();
let pos = if after { end } else { start };
(pos, idx, is_last)
};
let (rope_inserted, marker_byte_start, new_entry_pos, shift_threshold, shift_delta) = if !after
{
("\u{FFFC}\n", insert_pos, target_idx, insert_pos, 4i32)
} else if !target_is_last {
("\u{FFFC}\n", insert_pos, target_idx + 1, insert_pos, 4i32)
} else {
(
"\n\u{FFFC}",
insert_pos + 1,
target_idx + 1,
insert_pos,
4i32,
)
};
{
let mut rope = store.rope.write();
let char_idx = rope.byte_to_char(insert_pos as usize);
rope.insert(char_idx, rope_inserted);
}
store
.block_offsets
.write()
.shift_after(shift_threshold, shift_delta);
store.block_offsets.write().insert_at(
new_entry_pos,
OffsetMarker::TableAnchor(table_id),
marker_byte_start,
);
let _ = SENTINEL;
let _ = SENTINEL_BYTES;
}
pub fn rope_append_table_anchor(store: &Store, table_id: EntityId, needs_boundary: bool) {
let (anchor_byte_start, new_total) = {
let mut rope = store.rope.write();
let char_end = rope.len_chars();
let to_insert = if needs_boundary {
"\n\u{FFFC}"
} else {
"\u{FFFC}"
};
rope.insert(char_end, to_insert);
let new_total = rope.len_bytes() as u32;
let anchor_byte_start = new_total - 3;
(anchor_byte_start, new_total)
};
let mut offsets = store.block_offsets.write();
offsets.push(OffsetMarker::TableAnchor(table_id), anchor_byte_start);
offsets.set_total_bytes(new_total);
}
pub fn rope_remove_table_anchor(store: &Store, table_id: EntityId) {
let anchor_marker = OffsetMarker::TableAnchor(table_id);
let (anchor_byte_start, anchor_idx, anchor_is_last, has_predecessor) = {
let offsets = store.block_offsets.read();
let Some((start, _end)) = offsets.range_of(anchor_marker) else {
return;
};
let idx = offsets
.entries
.iter()
.position(|(m, _)| *m == anchor_marker)
.unwrap();
let is_last = idx + 1 == offsets.entries.len();
let has_pred = idx > 0;
(start, idx, is_last, has_pred)
};
let (remove_start, remove_end) = match (anchor_is_last, has_predecessor) {
(true, true) => (anchor_byte_start - 1, anchor_byte_start + 3),
(true, false) => (anchor_byte_start, anchor_byte_start + 3),
(false, _) => (anchor_byte_start, anchor_byte_start + 4),
};
{
let mut rope = store.rope.write();
let char_start = rope.byte_to_char(remove_start as usize);
let char_end = rope.byte_to_char(remove_end as usize);
rope.remove(char_start..char_end);
}
{
let mut offsets = store.block_offsets.write();
offsets.remove_at(anchor_idx);
}
store
.block_offsets
.write()
.shift_after(remove_end, -((remove_end - remove_start) as i32));
}
pub fn rope_remove_markers(store: &Store, markers: &[OffsetMarker]) {
let mut offsets = store.block_offsets.write();
let count = offsets.len();
let mut dropped = vec![false; count];
let mut any = false;
for marker in markers {
if let Some(position) = offsets.position_of(*marker) {
dropped[position] = true;
any = true;
}
}
if !any {
return;
}
let total = offsets.total_bytes();
let mut cuts: Vec<(u32, u32)> = Vec::new();
let mut position = 0;
while position < count {
if !dropped[position] {
position += 1;
continue;
}
let run_start = position;
while position < count && dropped[position] {
position += 1;
}
let first_byte = offsets.entries[run_start].1;
let cut = if position < count {
(first_byte, offsets.entries[position].1)
} else if run_start > 0 {
(first_byte.saturating_sub(1), total)
} else {
(0, total)
};
if cut.1 > cut.0 {
cuts.push(cut);
}
}
{
let mut rope = store.rope.write();
for &(start, end) in cuts.iter().rev() {
let char_start = rope.byte_to_char(start as usize);
let char_end = rope.byte_to_char(end as usize);
rope.remove(char_start..char_end);
}
}
offsets.remove_entries(&dropped, &cuts);
}
pub fn changed_span(
before: &ropey::Rope,
after: &ropey::Rope,
from: usize,
) -> (usize, usize, usize) {
let (old_len, new_len) = (before.len_chars(), after.len_chars());
let shorter = old_len.min(new_len);
let from = from.min(shorter);
let mut prefix = 0;
{
let mut old_chars = before.chars();
let mut new_chars = after.chars();
while prefix < from {
match (old_chars.next(), new_chars.next()) {
(Some(old), Some(new)) if old == new => prefix += 1,
_ => break,
}
}
}
let mut suffix = 0;
{
let reach = shorter - prefix;
let mut old_chars = before.chars_at(old_len);
let mut new_chars = after.chars_at(new_len);
while suffix < reach {
match (old_chars.prev(), new_chars.prev()) {
(Some(old), Some(new)) if old == new => suffix += 1,
_ => break,
}
}
}
let (old_end, new_end) = (old_len - suffix, new_len - suffix);
if prefix == from {
let mut old_chars = before.chars_at(from);
let mut new_chars = after.chars_at(from);
while prefix < old_end.min(new_end) {
match (old_chars.next(), new_chars.next()) {
(Some(old), Some(new)) if old == new => prefix += 1,
_ => break,
}
}
}
(prefix, old_end, new_end)
}
pub fn snap_off_table_anchor(store: &Store, position: i64, forward: bool) -> i64 {
if !rope_positions_match_flow(store) {
return position;
}
let rope = store.rope.read();
let clamped = position.clamp(0, rope.len_chars() as i64);
let byte = rope.char_to_byte(clamped as usize) as u32;
let offsets = store.block_offsets.read();
let Some(marker @ OffsetMarker::TableAnchor(_)) = offsets.marker_at_byte(byte) else {
return position;
};
let Some(index) = offsets.position_of(marker) else {
return position;
};
let is_anchor = |i: usize| {
offsets
.entries
.get(i)
.is_some_and(|(entry, _)| !entry.is_block())
};
let target = if forward {
let mut next = index + 1;
while is_anchor(next) {
next += 1;
}
offsets
.entries
.get(next)
.map_or_else(|| offsets.total_bytes(), |(_, start)| *start)
} else {
let mut first = index;
while first > 0 && is_anchor(first - 1) {
first -= 1;
}
offsets
.entries
.get(first)
.map_or(0, |(_, start)| start.saturating_sub(1))
};
rope.byte_to_char(target as usize) as i64
}
pub fn table_anchor_position(store: &Store, table_id: EntityId) -> Option<i64> {
if !rope_positions_match_flow(store) {
return None;
}
let (byte, _) = store
.block_offsets
.read()
.range_of(OffsetMarker::TableAnchor(table_id))?;
Some(store.rope.read().byte_to_char(byte as usize) as i64)
}
pub fn range_covers_table_anchor(store: &Store, start: i64, end: i64) -> bool {
if start >= end || !rope_positions_match_flow(store) {
return false;
}
let rope = store.rope.read();
let total = rope.len_chars() as i64;
let byte_of = |position: i64| rope.char_to_byte(position.clamp(0, total) as usize) as u32;
let (from, to) = (byte_of(start), byte_of(end));
let offsets = store.block_offsets.read();
let first = offsets.entries.partition_point(|(_, byte)| *byte < from);
offsets.entries[first..]
.iter()
.take_while(|(_, byte)| *byte < to)
.any(|(marker, _)| !marker.is_block())
}
pub fn holds_a_table_from_its_anchor(
store: &Store,
requested_start: i64,
start: i64,
end: i64,
) -> bool {
if requested_start >= start {
return false;
}
let table_ids: Vec<EntityId> = store.tables.read().keys().copied().collect();
table_ids.into_iter().any(|table_id| {
let Some(anchor) = table_anchor_position(store, table_id) else {
return false;
};
if anchor < requested_start || anchor >= start {
return false;
}
let table_end = {
let offsets = store.block_offsets.read();
let rope = store.rope.read();
table_block_ids(store, table_id)
.iter()
.filter_map(|block_id| offsets.range_with_successor(OffsetMarker::Block(*block_id)))
.map(|(block_start, block_end, has_successor)| {
let text_end = if has_successor && block_end > block_start {
block_end - 1
} else {
block_end
};
rope.byte_to_char(text_end as usize) as i64
})
.max()
};
table_end.is_some_and(|table_end| end >= table_end)
})
}
pub fn range_holds_a_whole_table(store: &Store, start: i64, end: i64) -> bool {
let snapped_start = snap_off_table_anchor(store, start, true);
let snapped_end = snap_off_table_anchor(store, end, false);
range_covers_table_anchor(store, snapped_start, snapped_end)
|| holds_a_table_from_its_anchor(store, start, snapped_start, snapped_end)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TableExtent {
pub table_id: EntityId,
pub anchor: i64,
pub end: i64,
}
impl TableExtent {
fn holds_start(&self, start: i64) -> bool {
self.anchor < start && start <= self.end
}
fn holds_end(&self, store: &Store, end: i64) -> bool {
let end = snap_off_table_anchor(store, end, false);
self.anchor < end && end <= self.end
}
}
pub fn table_extents(store: &Store) -> Vec<TableExtent> {
if !rope_positions_match_flow(store) {
return Vec::new();
}
let table_ids: Vec<EntityId> = store.tables.read().keys().copied().collect();
let mut extents: Vec<TableExtent> = table_ids
.into_iter()
.filter_map(|table_id| extent_of(store, table_id))
.collect();
extents.sort_unstable_by_key(|extent| extent.anchor);
extents
}
pub fn table_extent(store: &Store, table_id: EntityId) -> Option<TableExtent> {
if !rope_positions_match_flow(store) {
return None;
}
extent_of(store, table_id)
}
fn extent_of(store: &Store, table_id: EntityId) -> Option<TableExtent> {
let blocks = table_block_ids(store, table_id);
let offsets = store.block_offsets.read();
let anchor_index = offsets.position_of(OffsetMarker::TableAnchor(table_id))?;
let last_index = blocks
.iter()
.filter_map(|block_id| offsets.position_of(OffsetMarker::Block(*block_id)))
.max()
.unwrap_or(anchor_index)
.max(anchor_index);
let rope = store.rope.read();
let char_of = |byte: u32| rope.byte_to_char(byte as usize) as i64;
let (_, anchor_byte) = offsets.entries.get(anchor_index)?;
let end = offsets
.entries
.get(last_index + 1)
.map_or(rope.len_chars() as i64, |(_, next)| {
char_of(next.saturating_sub(1))
});
Some(TableExtent {
table_id,
anchor: char_of(*anchor_byte),
end,
})
}
pub fn take_whole_tables(store: &Store, start: i64, end: i64) -> (i64, i64) {
if start >= end || store.tables.read().is_empty() {
return (start, end);
}
let extents = table_extents(store);
let (mut start, mut end) = (start, end);
for _ in 0..=extents.len() {
let mut moved = false;
for extent in &extents {
if extent.holds_start(start) && end > extent.end {
start = extent.anchor;
moved = true;
}
if start < extent.anchor && extent.holds_end(store, end) && end < extent.end {
end = extent.end;
moved = true;
}
}
if !moved {
break;
}
}
(start, end)
}
pub fn rope_remove_block(store: &Store, block_id: EntityId) {
let block_marker = OffsetMarker::Block(block_id);
let (block_start, block_end, idx, is_last, has_pred) = {
let offsets = store.block_offsets.read();
let Some((start, end)) = offsets.range_of(block_marker) else {
return;
};
let Some(idx) = offsets.position_of(block_marker) else {
return;
};
let is_last = idx + 1 == offsets.entries.len();
let has_pred = idx > 0;
(start, end, idx, is_last, has_pred)
};
let (remove_start, remove_end) = if is_last && has_pred {
(block_start.saturating_sub(1), block_end)
} else {
(block_start, block_end)
};
if remove_end <= remove_start {
store.block_offsets.write().remove_at(idx);
return;
}
let deleted_bytes = remove_end - remove_start;
{
let mut rope = store.rope.write();
let char_start = rope.byte_to_char(remove_start as usize);
let char_end = rope.byte_to_char(remove_end as usize);
rope.remove(char_start..char_end);
}
store.block_offsets.write().remove_at(idx);
store
.block_offsets
.write()
.shift_after(remove_end, -(deleted_bytes as i32));
}
pub fn rope_replace_block_content(store: &Store, block_id: EntityId, new_text: &str) {
let (block_byte_start, content_bytes) = {
let offsets = store.block_offsets.read();
let Some((start, end, has_successor)) =
offsets.range_with_successor(OffsetMarker::Block(block_id))
else {
return;
};
let content_bytes = if has_successor && end > start {
end - start - 1
} else {
end - start
};
(start, content_bytes)
};
let new_bytes = new_text.len() as u32;
if content_bytes == 0 && new_bytes == 0 {
return;
}
let delta = new_bytes as i32 - content_bytes as i32;
{
let mut rope = store.rope.write();
let char_start = rope.byte_to_char(block_byte_start as usize);
if content_bytes > 0 {
let char_end = rope.byte_to_char((block_byte_start + content_bytes) as usize);
rope.remove(char_start..char_end);
}
if new_bytes > 0 {
rope.insert(char_start, new_text);
}
}
if delta != 0 {
store
.block_offsets
.write()
.shift_after(block_byte_start + 1, delta);
}
}
pub fn rope_clear_blocks(store: &Store, block_ids: &[EntityId]) {
let mut cuts: Vec<(usize, u32, u32)> = Vec::with_capacity(block_ids.len());
{
let offsets = store.block_offsets.read();
let mut previous: Option<usize> = None;
let mut in_index_order = true;
for &block_id in block_ids {
let marker = OffsetMarker::Block(block_id);
let (Some((start, end, has_successor)), Some(position)) = (
offsets.range_with_successor(marker),
offsets.position_of(marker),
) else {
continue;
};
if previous.is_some_and(|before| position <= before) {
in_index_order = false;
break;
}
previous = Some(position);
let content = if has_successor && end > start {
end - start - 1
} else {
end - start
};
if content > 0 {
cuts.push((position, start, content));
}
}
if !in_index_order {
drop(offsets);
for &block_id in block_ids {
rope_replace_block_content(store, block_id, "");
}
return;
}
}
if cuts.is_empty() {
return;
}
{
let mut rope = store.rope.write();
for &(_, start, content) in cuts.iter().rev() {
let char_start = rope.byte_to_char(start as usize);
let char_end = rope.byte_to_char((start + content) as usize);
rope.remove(char_start..char_end);
}
}
let shifts: Vec<(usize, u32)> = cuts
.iter()
.map(|&(position, _, content)| (position, content))
.collect();
store.block_offsets.write().remove_bytes_after(&shifts);
}
pub fn rope_delete_in_block(
store: &Store,
block_id: EntityId,
byte_start_in_block: u32,
byte_end_in_block: u32,
) {
if byte_end_in_block <= byte_start_in_block {
return;
}
let deleted_bytes = byte_end_in_block - byte_start_in_block;
let block_byte_start = {
let offsets = store.block_offsets.read();
let Some((start, _end)) = offsets.range_of_block(block_id) else {
return;
};
start
};
let rope_byte_start = block_byte_start + byte_start_in_block;
let rope_byte_end = block_byte_start + byte_end_in_block;
{
let mut rope = store.rope.write();
let char_start = rope.byte_to_char(rope_byte_start as usize);
let char_end = rope.byte_to_char(rope_byte_end as usize);
rope.remove(char_start..char_end);
}
store
.block_offsets
.write()
.shift_after(block_byte_start + 1, -(deleted_bytes as i32));
}
pub fn recompute_all_frame_byte_ranges(store: &Store) {
let frame_ids: Vec<EntityId> = {
let frames = store.frames.read();
frames.keys().copied().collect()
};
for fid in frame_ids {
let new_range = compute_frame_byte_range_recursive(store, fid);
let mut frames = store.frames.write();
if let Some(f) = frames.get(&fid).cloned()
&& f.byte_range != new_range
{
let mut updated = f;
updated.byte_range = new_range;
frames.insert(fid, updated);
}
}
}
fn compute_frame_byte_range_recursive(store: &Store, frame_id: EntityId) -> (u32, u32) {
let mut bounds: Option<(u32, u32)> = None;
walk_frame_bounds(store, frame_id, &mut bounds);
bounds.unwrap_or((0, 0))
}
fn walk_frame_bounds(store: &Store, frame_id: EntityId, bounds: &mut Option<(u32, u32)>) {
fn merge(bounds: &mut Option<(u32, u32)>, s: u32, e: u32) {
*bounds = Some(match *bounds {
None => (s, e),
Some((min, max)) => (min.min(s), max.max(e)),
});
}
let (blocks, child_order, table_id) = {
let frames = store.frames.read();
let Some(f) = frames.get(&frame_id) else {
return;
};
(f.blocks.clone(), f.child_order.clone(), f.table)
};
{
let offsets = store.block_offsets.read();
for bid in &blocks {
if let Some((s, e)) = offsets.range_of_block(*bid) {
merge(bounds, s, e);
}
}
if let Some(tid) = table_id
&& let Some((s, e)) = offsets.range_of(OffsetMarker::TableAnchor(tid))
{
merge(bounds, s, e);
}
}
for entry in &child_order {
if *entry < 0 {
walk_frame_bounds(store, (-*entry) as EntityId, bounds);
}
}
if let Some(tid) = table_id {
let cell_ids: Vec<EntityId> = {
let tables = store.tables.read();
tables
.get(&tid)
.map(|t| t.cells.clone())
.unwrap_or_default()
};
for cell_id in &cell_ids {
let cell_frame_id = {
let cells = store.table_cells.read();
cells.get(cell_id).and_then(|c| c.cell_frame)
};
if let Some(cfid) = cell_frame_id {
walk_frame_bounds(store, cfid, bounds);
}
}
}
}
pub fn replace_in_block(
store: &Store,
block: &Block,
char_start: i64,
char_end: i64,
replacement: &str,
policy: ReplaceFormatPolicy,
) -> Result<Block, FormatRunError> {
replace_in_blocks(
store,
&[BlockReplacement {
block,
char_start,
char_end,
replacement,
}],
policy,
)?;
let mut updated = block.clone();
updated.updated_at = chrono::Utc::now();
Ok(updated)
}
#[derive(Debug, Clone, Copy)]
pub struct BlockReplacement<'a> {
pub block: &'a Block,
pub char_start: i64,
pub char_end: i64,
pub replacement: &'a str,
}
pub fn replace_in_blocks(
store: &Store,
edits: &[BlockReplacement<'_>],
policy: ReplaceFormatPolicy,
) -> Result<(), FormatRunError> {
let mut order: Vec<&Block> = Vec::new();
let mut of_block: HashMap<EntityId, Vec<&BlockReplacement<'_>>> = HashMap::new();
for edit in edits {
let group = of_block.entry(edit.block.id).or_default();
if group.is_empty() {
order.push(edit.block);
}
group.push(edit);
}
struct NewState<'a> {
block_id: EntityId,
runs: Vec<FormatRun>,
images: Vec<ImageAnchor>,
notes: Option<Vec<FootnoteRefAnchor>>,
splices: Vec<(u32, u32, &'a str)>,
}
let mut states: Vec<NewState<'_>> = Vec::with_capacity(order.len());
for block in order {
let group = of_block.remove(&block.id).unwrap_or_default();
let images_before = store
.block_images
.read()
.get(&block.id)
.cloned()
.unwrap_or_default();
let block_text = block_content_via_store(block, store);
let mut splices: Vec<(u32, u32, &str)> = Vec::with_capacity(group.len());
for edit in group {
let byte_start = logical_offset_to_byte(&block_text, &images_before, edit.char_start);
let byte_end = logical_offset_to_byte(&block_text, &images_before, edit.char_end);
if byte_end < byte_start {
return Err(FormatRunError::ReversedRange {
start: byte_start,
end: byte_end,
});
}
splices.push((byte_start, byte_end, edit.replacement));
}
splices.sort_by_key(|(start, end, _)| (*start, *end));
if let Some(pair) = splices.windows(2).find(|pair| pair[0].1 > pair[1].0) {
return Err(FormatRunError::ReversedRange {
start: pair[0].1,
end: pair[1].0,
});
}
let mut runs = store
.format_runs
.read()
.get(&block.id)
.cloned()
.unwrap_or_default();
let mut images = images_before;
let mut notes = store.block_footnote_refs.read().get(&block.id).cloned();
let mut new_len = block_text.len();
for &(byte_start, byte_end, replacement) in splices.iter().rev() {
let inserted = replacement.len() as u32;
shift_runs_for_replace(&mut runs, byte_start, byte_end, inserted, policy)?;
shift_images_for_delete(&mut images, byte_start, byte_end);
shift_images_for_insert(&mut images, byte_start, inserted);
if let Some(notes) = notes.as_mut() {
shift_footnote_refs_for_delete(notes, byte_start, byte_end);
shift_footnote_refs_for_insert(notes, byte_start, inserted);
}
new_len = new_len - (byte_end - byte_start) as usize + replacement.len();
}
check_well_formed(&runs, new_len)?;
states.push(NewState {
block_id: block.id,
runs,
images,
notes,
splices,
});
}
let mut rope_splices: Vec<(u32, u32, &str)> = Vec::new();
let mut shifts: Vec<(u32, i32)> = Vec::new();
{
let offsets = store.block_offsets.read();
let mut runs_map = store.format_runs.write();
let mut images_map = store.block_images.write();
let mut notes_map = store.block_footnote_refs.write();
for state in states {
runs_map.insert(state.block_id, state.runs);
images_map.insert(state.block_id, state.images);
if let Some(notes) = state.notes {
notes_map.insert(state.block_id, notes);
}
let Some((block_start, _)) = offsets.range_of_block(state.block_id) else {
continue;
};
let mut delta: i64 = 0;
for (byte_start, byte_end, replacement) in state.splices {
rope_splices.push((
block_start + byte_start,
block_start + byte_end,
replacement,
));
delta += replacement.len() as i64 - (byte_end - byte_start) as i64;
}
if delta != 0 {
shifts.push((block_start + 1, delta as i32));
}
}
}
rope_splices.sort_by_key(|(start, end, _)| (*start, *end));
{
let mut rope = store.rope.write();
for &(byte_start, byte_end, replacement) in rope_splices.iter().rev() {
let char_start = rope.byte_to_char(byte_start as usize);
if byte_end > byte_start {
let char_end = rope.byte_to_char(byte_end as usize);
rope.remove(char_start..char_end);
}
if !replacement.is_empty() {
rope.insert(char_start, replacement);
}
}
}
shifts.sort_by_key(|(threshold, _)| *threshold);
store.block_offsets.write().shift_after_each(&shifts);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::database::block_offset_index::tests::ENTRIES_REWRITTEN;
use crate::entities::{Document, Frame};
use std::cell::Cell;
thread_local! {
pub(super) static LOOKED_AT: Cell<usize> = const { Cell::new(0) };
}
fn text_with_notes(paragraphs: u64, notes: u64) -> (Store, i64) {
let store = Store::new();
let main: EntityId = 1;
let mut frames = vec![Frame {
id: main,
..Frame::default()
}];
let mut end = 0;
let mut next_block: EntityId = 1;
for i in 0..paragraphs {
if next_block > 1 {
rope_insert_block_boundary(&store);
}
let text = format!("Paragraph {i}.");
end = store.rope.read().len_chars() as i64 + text.chars().count() as i64;
rope_append_block(&store, next_block, &text);
frames[0].blocks.push(next_block);
frames[0].child_order.push(next_block as i64);
next_block += 1;
}
for i in 0..notes {
rope_insert_block_boundary(&store);
rope_append_block(&store, next_block, &format!("Note {i}."));
frames.push(Frame {
id: main + 1 + i,
blocks: vec![next_block],
child_order: vec![next_block as i64],
footnote_label: Some(format!("n{i}")),
..Frame::default()
});
next_block += 1;
}
{
let mut blocks = store.blocks.write();
for id in 1..next_block {
blocks.insert(
id,
Block {
id,
..Block::default()
},
);
}
}
store.documents.write().insert(
1,
Document {
id: 1,
frames: frames.iter().map(|frame| frame.id).collect(),
..Document::default()
},
);
let mut stored = store.frames.write();
for frame in frames {
stored.insert(frame.id, frame);
}
drop(stored);
(store, end)
}
#[test]
fn the_end_of_the_main_text_costs_the_same_however_many_notes_follow() {
let mut looked = Vec::new();
for (paragraphs, notes) in [(50, 100), (50, 2_000), (1_000, 2_000)] {
let (store, end) = text_with_notes(paragraphs, notes);
LOOKED_AT.with(|looked| looked.set(0));
assert_eq!(
main_text_end(&store),
Some(end),
"{paragraphs} paragraphs, {notes} notes"
);
looked.push(LOOKED_AT.with(Cell::get));
}
assert!(
looked.windows(2).all(|pair| pair[0] == pair[1]),
"the end of the main text looked at {looked:?} frames and entries for 100 and \
2,000 notes, then 1,000 paragraphs"
);
let (store, _) = text_with_notes(20, 0);
assert_eq!(main_text_end(&store), None);
}
fn blocks(blocks: u64) -> (Store, Vec<EntityId>) {
let store = Store::new();
let ids: Vec<EntityId> = (1..=blocks).collect();
for &id in &ids {
if id > 1 {
rope_insert_block_boundary(&store);
}
rope_append_block(&store, id, &format!("cell {id}"));
}
(store, ids)
}
#[test]
fn clearing_blocks_together_walks_the_index_once() {
const BLOCKS: u64 = 1_000;
let (one_by_one, ids) = blocks(BLOCKS);
let (together, _) = blocks(BLOCKS);
let cleared: Vec<EntityId> = ids.iter().copied().step_by(4).collect();
ENTRIES_REWRITTEN.with(|rewritten| rewritten.set(0));
for &id in &cleared {
rope_replace_block_content(&one_by_one, id, "");
}
let block_by_block = ENTRIES_REWRITTEN.with(Cell::get);
ENTRIES_REWRITTEN.with(|rewritten| rewritten.set(0));
rope_clear_blocks(&together, &cleared);
let in_one_walk = ENTRIES_REWRITTEN.with(Cell::get);
assert_eq!(
*together.rope.read(),
*one_by_one.rope.read(),
"the same text is left"
);
assert_eq!(
*together.block_offsets.read(),
*one_by_one.block_offsets.read(),
"the same index is left"
);
assert!(
block_by_block > 100 * BLOCKS as usize,
"clearing block by block rewrote {block_by_block} entries"
);
assert_eq!(
in_one_walk,
BLOCKS as usize,
"clearing {} blocks together rewrote {in_one_walk} index entries, where one walk \
of the {BLOCKS} entries is enough",
cleared.len()
);
}
#[test]
fn replacing_in_many_blocks_walks_the_index_once() {
const BLOCKS: u64 = 1_000;
let (one_by_one, ids) = blocks(BLOCKS);
let (together, _) = blocks(BLOCKS);
let entities: Vec<Block> = ids
.iter()
.map(|&id| Block {
id,
..Block::default()
})
.collect();
let edits: Vec<BlockReplacement<'_>> = entities
.iter()
.flat_map(|block| {
let end = format!("cell {}", block.id).chars().count() as i64;
[
BlockReplacement {
block,
char_start: 0,
char_end: 2,
replacement: "k",
},
BlockReplacement {
block,
char_start: end,
char_end: end,
replacement: "!?",
},
]
})
.collect();
ENTRIES_REWRITTEN.with(|rewritten| rewritten.set(0));
for edit in edits.iter().rev() {
replace_in_block(
&one_by_one,
edit.block,
edit.char_start,
edit.char_end,
edit.replacement,
ReplaceFormatPolicy::default(),
)
.unwrap();
}
let edit_by_edit = ENTRIES_REWRITTEN.with(Cell::get);
ENTRIES_REWRITTEN.with(|rewritten| rewritten.set(0));
replace_in_blocks(&together, &edits, ReplaceFormatPolicy::default()).unwrap();
let in_one_walk = ENTRIES_REWRITTEN.with(Cell::get);
assert_eq!(
*together.rope.read(),
*one_by_one.rope.read(),
"the same text is left"
);
assert_eq!(
*together.block_offsets.read(),
*one_by_one.block_offsets.read(),
"the same index is left"
);
assert!(
together
.rope
.read()
.to_string()
.starts_with("kll 1!?\nkll 2!?\n")
);
assert!(
edit_by_edit > 100 * BLOCKS as usize,
"replacing edit by edit rewrote {edit_by_edit} entries"
);
assert!(
in_one_walk <= BLOCKS as usize,
"{} replacements together rewrote {in_one_walk} index entries, where one walk of \
the {BLOCKS} entries is enough",
edits.len()
);
}
#[test]
fn overlapping_replacements_change_nothing() {
let store = blocks_holding(&["alpha", "beta"]);
let block = Block {
id: 1,
..Block::default()
};
let edits = [
BlockReplacement {
block: &block,
char_start: 0,
char_end: 3,
replacement: "x",
},
BlockReplacement {
block: &block,
char_start: 2,
char_end: 4,
replacement: "y",
},
];
assert!(replace_in_blocks(&store, &edits, ReplaceFormatPolicy::default()).is_err());
assert_eq!(store.rope.read().to_string(), "alpha\nbeta");
}
fn blocks_holding(texts: &[&str]) -> Store {
let store = Store::new();
for (i, text) in texts.iter().enumerate() {
if i > 0 {
rope_insert_block_boundary(&store);
}
rope_append_block(&store, i as EntityId + 1, text);
}
store
}
#[test]
fn emptying_the_block_before_an_empty_last_block_keeps_the_boundary() {
for together in [false, true] {
let store = blocks_holding(&["text", ""]);
if together {
rope_clear_blocks(&store, &[1]);
} else {
rope_replace_block_content(&store, 1, "");
}
assert_eq!(store.rope.read().to_string(), "\n", "together: {together}");
let offsets = store.block_offsets.read();
assert_eq!(
*offsets.entries,
vec![(OffsetMarker::Block(1), 0), (OffsetMarker::Block(2), 1)],
"together: {together}"
);
assert_eq!(offsets.total_bytes(), 1);
}
}
#[test]
fn a_position_on_a_chain_of_anchors_snaps_past_the_whole_chain() {
let with_anchors = |texts: &[&str], anchors: &[usize]| {
let store = blocks_holding(texts);
{
let mut offsets = store.block_offsets.write();
let mut entries = (*offsets.entries).clone();
for (i, entry) in entries.iter_mut().enumerate() {
if anchors.contains(&i) {
entry.0 = OffsetMarker::TableAnchor(100 + i as EntityId);
}
}
offsets.entries = std::sync::Arc::new(entries);
offsets.rebuild_marker_index();
}
{
let mut blocks = store.blocks.write();
for id in 1..=texts.len() as EntityId {
if !anchors.contains(&(id as usize - 1)) {
blocks.insert(
id,
Block {
id,
..Block::default()
},
);
}
}
}
store
};
let store = with_anchors(
&[
"Before.", "\u{FFFC}", "\u{FFFC}", "inner", "outer", "After.",
],
&[1, 2],
);
for on_chain in 8..=11 {
assert_eq!(
snap_off_table_anchor(&store, on_chain, true),
12,
"from {on_chain}"
);
assert_eq!(
snap_off_table_anchor(&store, on_chain, false),
7,
"from {on_chain}"
);
}
for off_chain in [0, 6, 7, 12, 17] {
assert_eq!(snap_off_table_anchor(&store, off_chain, true), off_chain);
assert_eq!(snap_off_table_anchor(&store, off_chain, false), off_chain);
}
let store = with_anchors(&["\u{FFFC}", "\u{FFFC}", "cell"], &[0, 1]);
for on_chain in 0..=3 {
assert_eq!(
snap_off_table_anchor(&store, on_chain, true),
4,
"from {on_chain}"
);
assert_eq!(
snap_off_table_anchor(&store, on_chain, false),
0,
"from {on_chain}"
);
}
}
#[test]
fn a_range_covers_a_table_when_it_holds_its_anchor() {
let store = blocks_holding(&["Before.", "\u{FFFC}", "cell", "After."]);
{
let mut offsets = store.block_offsets.write();
let mut entries = (*offsets.entries).clone();
entries[1].0 = OffsetMarker::TableAnchor(40);
offsets.entries = std::sync::Arc::new(entries);
offsets.rebuild_marker_index();
}
{
let mut blocks = store.blocks.write();
for id in [1, 3, 4] {
blocks.insert(
id,
Block {
id,
..Block::default()
},
);
}
}
for (start, end, covers) in [
(0, 8, false),
(0, 9, true),
(7, 9, true),
(8, 9, true),
(9, 20, false),
(7, 15, true),
(14, 15, false),
(9, 9, false),
] {
assert_eq!(
range_covers_table_anchor(&store, start, end),
covers,
"{start}..{end}"
);
}
}
fn layout_of(entries: &[Option<&str>]) -> (Store, Vec<OffsetMarker>) {
let texts: Vec<&str> = entries
.iter()
.map(|entry| entry.unwrap_or("\u{FFFC}"))
.collect();
let store = blocks_holding(&texts);
let markers: Vec<OffsetMarker> = entries
.iter()
.enumerate()
.map(|(i, entry)| match entry {
Some(_) => OffsetMarker::Block(i as EntityId + 1),
None => OffsetMarker::TableAnchor(i as EntityId + 1),
})
.collect();
{
let mut offsets = store.block_offsets.write();
let mut indexed = (*offsets.entries).clone();
for (slot, marker) in indexed.iter_mut().zip(&markers) {
slot.0 = *marker;
}
offsets.entries = std::sync::Arc::new(indexed);
offsets.rebuild_marker_index();
}
(store, markers)
}
#[test]
fn removing_markers_together_matches_removing_them_one_at_a_time() {
let layouts: [&[Option<&str>]; 7] = [
&[
Some("one"),
Some(""),
Some("three"),
None,
Some("five"),
Some(""),
],
&[Some("Hello"), Some(""), None],
&[Some(""), None],
&[None],
&[None, Some("")],
&[Some("x"), None, Some(""), None, Some("")],
&[Some(""), None, Some("a"), Some("b"), None],
];
for entries in layouts {
for subset in 1u32..(1 << entries.len()) {
let (_, markers) = layout_of(entries);
let chosen: Vec<OffsetMarker> = markers
.iter()
.enumerate()
.filter(|(i, _)| subset & (1 << i) != 0)
.map(|(_, marker)| *marker)
.collect();
let mut expected_text = String::new();
let mut expected_entries: Vec<(OffsetMarker, u32)> = Vec::new();
for (entry, marker) in entries.iter().zip(&markers) {
if chosen.contains(marker) {
continue;
}
if !expected_entries.is_empty() {
expected_text.push('\n');
}
expected_entries.push((*marker, expected_text.len() as u32));
expected_text.push_str(entry.unwrap_or("\u{FFFC}"));
}
let (one_by_one, _) = layout_of(entries);
for marker in &chosen {
match marker {
OffsetMarker::Block(id) => rope_remove_block(&one_by_one, *id),
OffsetMarker::TableAnchor(id) => rope_remove_table_anchor(&one_by_one, *id),
}
}
let (together, _) = layout_of(entries);
rope_remove_markers(&together, &chosen);
for (how, store) in [("one by one", &one_by_one), ("together", &together)] {
assert_eq!(
store.rope.read().to_string(),
expected_text,
"{how}, removing {chosen:?} from {entries:?}"
);
let offsets = store.block_offsets.read();
assert_eq!(
*offsets.entries, expected_entries,
"{how}, removing {chosen:?} from {entries:?}"
);
assert_eq!(
offsets.total_bytes() as usize,
expected_text.len(),
"{how}, removing {chosen:?} from {entries:?}"
);
}
}
}
}
#[test]
fn a_changed_span_is_found_where_the_edit_went() {
let span = |before: &str, after: &str, from: usize| {
changed_span(
&ropey::Rope::from_str(before),
&ropey::Rope::from_str(after),
from,
)
};
assert_eq!(span("Hello world", "Hello big world", 6), (6, 6, 10));
assert_eq!(span("X inserted Y", "X insertedinserted Y", 2), (2, 2, 10));
assert_eq!(
span("one two\nthree", "one two\n\u{FFFC}\nx\ny\nthree", 3),
(7, 7, 13)
);
assert_eq!(span("a\nbcd\ne", "a\nx\ny\ne", 4), (2, 5, 5));
assert_eq!(span("same", "same", 2), (2, 2, 2));
}
}