Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Merge tested main 0f4f382b0eb6 into PR #458

sanyamsingh00117e280335a45
diff --cc crates/doc/src/slice.rs
index 7bbb58f6b,ebf59b6a8..a7ec02fe1
--- a/crates/doc/src/slice.rs
+++ b/crates/doc/src/slice.rs
@@@ -184,123 -220,51 +244,171 @@@ mod tests
assert!(a.extract(2..8).notes.is_empty());
}
+ fn append_note_pair(st: &mut Story, text: &str) {
+ st.insert_endnote(st.len(), text, ParaFormat::default());
+ st.insert(st.len(), &NOTE_MARK.to_string());
+ let note = Arc::make_mut(st.editorial.last_mut().unwrap());
+ note.text = text.into();
+ note.author = format!("{text} author");
+ }
+
+ #[test]
+ fn clipped_endnotes_and_editorial_keep_payloads_with_fresh_destination_ids() {
+ let mut source = Story::new(StoryId(1));
+ append_note_pair(&mut source, "outside before");
+ let start = source.len();
+ append_note_pair(&mut source, "Citation é\nsecond");
+ let end = source.len();
+ let citation = &mut Arc::make_mut(&mut source.endnotes[1]).text;
+ citation.format_chars(0..8, |f| f.over.size = Some(19.0));
+ citation.paras[1].style = "Citation".into();
+ append_note_pair(&mut source, "outside after");
+ source.check().unwrap();
+ let original = source.clone();
+ let slice = source.extract(start..end);
+ slice.check().unwrap();
+ assert_eq!(slice.text, format!("{ENDNOTE_REF}{NOTE_MARK}"));
+ assert_eq!(slice.endnotes, vec![source.endnotes[1].clone()]);
+ assert_eq!(slice.editorial, vec![source.editorial[1].clone()]);
+
+ let mut dest = Story::new(StoryId(2));
+ append_note_pair(&mut dest, "destination before");
+ let at = dest.len();
+ append_note_pair(&mut dest, "destination after");
+ let before = dest.clone();
+ assert_eq!(dest.insert_story(at, &slice), at + slice.len());
+ dest.check().unwrap();
+ assert_eq!(dest.text, format!("{ENDNOTE_REF}{NOTE_MARK}").repeat(3));
+ assert_eq!(dest.endnotes[1].text, slice.endnotes[0].text);
+ assert_eq!(dest.editorial[1].text, "Citation é\nsecond");
+ assert_eq!(dest.editorial[1].author, "Citation é\nsecond author");
+ assert_eq!((dest.endnotes[1].id, dest.editorial[1].id), (3, 3));
+ assert_eq!(dest.endnotes[0], before.endnotes[0]);
+ assert_eq!(dest.endnotes[2], before.endnotes[1]);
+ assert_eq!(dest.editorial[0], before.editorial[0]);
+ assert_eq!(dest.editorial[2], before.editorial[1]);
+ Arc::make_mut(&mut dest.endnotes[1]).text.insert(0, "changed");
+ Arc::make_mut(&mut dest.editorial[1]).author = "changed".into();
+ assert_eq!(source, original);
+ assert_eq!(slice.endnotes[0], original.endnotes[1]);
+ assert_eq!(slice.editorial[0], original.editorial[1]);
+ }
+
+ #[test]
+ fn extract_tolerates_missing_endnote_and_editorial_payloads() {
+ let mut source = Story::new(StoryId(1));
+ for text in ["before", "selected", "missing"] {
+ append_note_pair(&mut source, text);
+ }
+ let pair_len = ENDNOTE_REF.len_utf8() + NOTE_MARK.len_utf8();
+ for available in [0, 1, 2] {
+ let mut damaged = source.clone();
+ damaged.endnotes.truncate(available);
+ damaged.editorial.truncate(available);
+ let original = damaged.clone();
+ let slice = damaged.extract(pair_len..damaged.len());
+ assert_eq!(slice.text, format!("{ENDNOTE_REF}{NOTE_MARK}").repeat(2));
+ let expected = if available == 2 { 1 } else { 0 };
+ assert_eq!((slice.endnotes.len(), slice.editorial.len()), (expected, expected));
+ if expected == 1 {
+ assert_eq!(slice.endnotes[0], source.endnotes[1]);
+ assert_eq!(slice.editorial[0], source.editorial[1]);
+ }
+ let mut dest = Story::new(StoryId(2));
+ append_note_pair(&mut dest, "untouched");
+ let tail = dest.clone();
+ dest.insert_story(0, &slice);
+ dest.check().unwrap();
+ assert_eq!(dest.text, format!("{ENDNOTE_REF}{NOTE_MARK}").repeat(3));
+ assert_eq!((dest.endnotes.len(), dest.editorial.len()), (3, 3));
+ assert_eq!(dest.endnotes[2], tail.endnotes[0]);
+ assert_eq!(dest.editorial[2], tail.editorial[0]);
+ assert_eq!(dest.endnotes[0].text.text, if expected == 1 { "selected" } else { "" });
+ assert_eq!(dest.editorial[0].text, if expected == 1 { "selected" } else { "" });
+ assert!(dest.endnotes[1].text.is_empty());
+ assert!(dest.editorial[1].text.is_empty());
+ assert_eq!(damaged, original);
+ }
+ }
+
+ #[test]
+ fn append_tables_preserves_sparse_and_wrapping_ids() {
+ for existing in [vec![1, 3, u64::MAX], vec![1, 3, u64::MAX - 1], vec![1, 3, 8]] {
+ let story = |id, ids: &[u64]| {
+ let mut s = Story::with_text(StoryId(id), &vec![crate::TABLE_ANCHOR.to_string(); ids.len()].join("\n"), ParaFormat::default());
+ for (p, &tid) in s.paras.iter_mut().zip(ids) {
+ p.table = Some(tid);
+ let mut t = crate::table::Table::new(tid, 1, 1, 0, 0, 100.0);
+ t.cells[0].text = Story::with_text(StoryId(0), &format!("{id}:{tid}"), ParaFormat::default());
+ s.tables.insert(tid, Arc::new(t));
+ }
+ s
+ };
+ let mut a = story(1, &existing);
+ let b = story(2, &[1, 2, 3]);
+ a.check().unwrap();
+ b.check().unwrap();
+ a.append_story(b);
+ a.check().unwrap();
+ assert_eq!(a.tables.len(), 6);
+ for (p, tid) in a.paras.iter().take(3).zip(&existing) {
+ assert_eq!(p.table, Some(*tid));
+ assert_eq!(a.tables[tid].cells[0].text.text, format!("1:{tid}"));
+ }
+ for (p, tid) in a.paras.iter().skip(3).zip(1..=3) {
+ assert_eq!(a.tables[&p.table.unwrap()].cells[0].text.text, format!("2:{tid}"));
+ }
+ }
+ }
+
+ #[test]
+ fn excess_note_payloads_do_not_overwrite_destination_neighbors() {
+ let mut payload = Story::new(StoryId(1));
+ append_note_pair(&mut payload, "copied");
+ for has_markers in [false, true] {
+ let mut src = if has_markers { payload.clone() } else { Story::with_text(StoryId(1), "plain", ParaFormat::default()) };
+ src.endnotes.push(payload.endnotes[0].clone());
+ src.editorial.push(payload.editorial[0].clone());
+ let original = src.clone();
+ let mut dest = Story::new(StoryId(2));
+ append_note_pair(&mut dest, "before");
+ let at = dest.len();
+ append_note_pair(&mut dest, "after");
+ let before = dest.clone();
+ assert_eq!(dest.insert_story(at, &src), at + src.len());
+ dest.check().unwrap();
+ let pair = format!("{ENDNOTE_REF}{NOTE_MARK}");
+ assert_eq!(dest.text, format!("{pair}{}{pair}", src.text));
+ let tail = if has_markers { 2 } else { 1 };
+ assert_eq!((dest.endnotes.len(), dest.editorial.len()), (tail + 1, tail + 1));
+ assert_eq!(dest.endnotes[0], before.endnotes[0]);
+ assert_eq!(dest.endnotes[tail], before.endnotes[1]);
+ assert_eq!(dest.editorial[0], before.editorial[0]);
+ assert_eq!(dest.editorial[tail], before.editorial[1]);
+ if has_markers {
+ assert_eq!(dest.endnotes[1].text, payload.endnotes[0].text);
+ assert_eq!((dest.editorial[1].text.as_str(), dest.editorial[1].author.as_str()), ("copied", "copied author"));
+ assert_eq!((dest.endnotes[1].id, dest.editorial[1].id), (3, 3));
+ }
+ assert_eq!(src, original);
+ }
+ }
++
+ #[test]
+ fn append_story_with_maximal_ids_does_not_overflow() {
+ let mut a = Story::with_text(StoryId(1), "Alpha", ParaFormat::default());
+ a.tables.insert(u64::MAX, Arc::new(crate::table::Table::new(u64::MAX, 1, 1, 0, 0, 100.0)));
+ let note = |id| Arc::new(crate::notes::Footnote { id, text: Story::with_text(StoryId(0), "n", ParaFormat::default()) });
+ a.endnotes.push(note(u64::MAX));
+ a.notes.push(note(u64::MAX));
+ a.rev = u64::MAX;
+ let mut b = Story::with_text(StoryId(2), "Beta", ParaFormat::default());
+ b.tables.insert(1, Arc::new(crate::table::Table::new(1, 1, 1, 0, 0, 100.0)));
+ b.endnotes.push(note(1));
+ b.notes.push(note(1));
+ a.append_story(b);
+ assert_eq!(a.text, "Alpha\nBeta");
+ assert_eq!(a.endnotes.len(), 2);
+ assert_eq!(a.notes.len(), 2);
+ }
}