Merge remote-tracking branch 'upstream/main' into codex/integrate-2658b

This commit is contained in:
Dylan M. Taylor committed 2026-11-12 16:27:39 -05:00
commit 076e653ac3
24 files changed
+2595 -136

No files matched your search

+7
View File
@@ -14,6 +14,12 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope
- **2026-11-06** · Automation roots refuse `COM¹` to `LPT³` and a device name before a colon (`COM1:`, `NUL:x`). A batch-export layout of that name is written with a leading `_` on every platform. No readiness percentage change.
- **2026-10-30** · Document Fonts lookup treats a bare document filename's empty parent as the current directory (#2014), preserving case-insensitive discovery and automation read-root checks. No readiness percentage change.
- **2026-10-27** · Automatic recovery writes off the interface thread, straight to disk: on a
190-page catalogue with 4.2 GB of placed files an autosave was 3.6 GB deflated in RAM on the
interface thread, which stopped the window answering for 30-100 s after an edit. It is now a
background write (`file.recovery.save {background}`, `file.recovery.progress`), the caller
blocked for 109 ms instead, and Save, Close and Revert cancel a snapshot still being written.
No readiness percentage change.
- **2026-10-28** · Inline table rows leave room for column and spanning footnotes, continuing in
the next column or frame when needed (#1901). Cell-local footnotes contribute to row height
and sit inside the cell rather than outside its measuring frame. Vertical justification keeps
@@ -391,6 +397,7 @@ list) · [roadmap.md](docs/roadmap.md) (milestones, plan) · [parity-checklist.m
- **2026-11-12** · An edit of a long threaded story composes the paragraphs it can change and copies the other lines from the composition before the edit; every typed character composed the whole story. In a 240-paragraph story a typed character composes 3 paragraphs (240 before). An edit that moves lines into other frames composes on until a paragraph starts in the same frame and place as before, or to the story's end, and stories with footnotes, tables, anchored objects, balanced columns or keep options that move lines are composed whole. No readiness percentage change.
- **2026-11-12** · Type shortcuts: Justify All Lines ⇧⌘F, Insert White Space › Em Space ⇧⌘M and En Space ⇧⌘N (shown in the menu, enabled at an insertion point), Paragraph Rules… ⌥⌘J (shown in the Paragraph panel menu). On the Mac a menu-bar insert (Em/En Space, Current Page Number) no longer types into the document while a text field has focus, a dialog or Quick Apply is open, or an input method is composing. An alignment the paragraphs already have records no undo step (#1138). No readiness percentage change.
- **2026-11-12** · The status bar's preflight count and the Preflight panel take their issues from a check on a background worker, which checks the newest state of the document and shows the issues last found meanwhile. Moving or resizing a frame and typing no longer wait for a check of the whole document on every drag step and keystroke. No readiness percentage change.
- **2026-11-12** · Object › Text Frame Options… (Cmd+B) opens with the Type tool in a frame, so inset spacing and vertical justification can be changed while typing; it changes the frame that shows the insertion point, or every frame that holds part of the selected text (#2396). No readiness percentage change.
- **2026-11-04** · Striped strokes retain out-and-back cubic segments whose second control point is away from the coincident endpoints and first control point. A geometry regression checks the offset extent and both stripe bands. No readiness percentage change.
- **2026-11-04** · Esperanto is a text language (Character › Language, `type.char {language: "Esperanto"}`, IDML `$ID/Esperanto`): tag `eo`, English-style quotes; not hyphenated yet (#1201). No readiness percentage change.
+4
View File
@@ -8,6 +8,10 @@ description = "DesignCraft engine: session, documents, history, selection, comma
[lints]
workspace = true
[features]
# Recovery-writer handshakes for other crates' tests (`designcraft_engine::recovery::testing`).
testing = []
[dependencies]
craft-print = { workspace = true }
craft-docpath = { workspace = true }
+1
View File
@@ -42,6 +42,7 @@ mod mathexpr;
mod media;
mod notes;
mod object;
pub use object::text_frame_options_frames;
mod overrides;
mod package;
pub mod params;
+15 -1
View File
@@ -67,10 +67,24 @@ pub fn specs() -> Vec<CommandSpec> {
let dir = recovery_dir(s, p, FolderAccess::Read)?;
Ok(Value::Array(crate::recovery::list(&dir).into_iter().map(|(uid, mut m)| { m["uid"] = json!(uid); m }).collect()))
}),
cmd!(noundo "file.recovery.save", "Save Recovery Data", [], None, "{dir?} — write every unsaved document to the recovery folder (the app does this on a timer)", always, |s, p| {
cmd!(noundo "file.recovery.save", "Save Recovery Data", [], None,
"{dir?, background?} — write every unsaved document to the recovery folder (the app does this on a timer; `background` queues the writes and returns at once) → {saved} or {queued}",
always, |s, p| {
let background = match p.get("background") {
None | Some(Value::Null) => false,
Some(v) => v.as_bool().ok_or_else(|| bad("file.recovery.save", "`background` must be true or false"))?,
};
let dir = recovery_dir(s, p, FolderAccess::Write)?;
if background {
return Ok(json!({"queued": crate::recovery::start_tracked(s, &dir)?}));
}
Ok(json!({"saved": crate::recovery::save_tracked(s, &dir)?}))
}),
cmd!(query "file.recovery.progress", "Recovery Progress", [], None,
"{} → {written, busy, errors} recovery data queued in the background has been written", always, |s, _| {
let done = crate::recovery::finished(s);
Ok(json!({"written": done.written, "busy": done.busy, "errors": done.errors}))
}),
cmd!(noundo "file.recovery.open", "Recover Documents", [], None, "{dir?} — reopen documents left in the recovery folder (unsaved)", always, |s, p| {
// Reopening removes the entries it read.
let dir = recovery_dir(s, p, FolderAccess::ReadWrite)?;
+372 -9
View File
@@ -610,8 +610,8 @@ pub fn specs() -> Vec<CommandSpec> {
"Text Frame Options…",
["Object"],
Some("Cmd+B"),
"{columns? (1..40), gutter? (pt, 0..15552), inset?: number|[t,l,b,r] (pt, each 0..15552; a list has four sides, null keeps that side), verticalJustification?: top|center|bottom|justify, paragraphSpacingLimit? (pt: Justify adds at most this between paragraphs, the rest between lines), columnsKind?: fixedNumber|fixedWidth|flexibleWidth, columnWidth? (pt, Fixed Width), firstBaseline?: ascent|capHeight|leading|xHeight|emboxHeight|fixed, firstBaselineMin? (pt), autoSize?: off|heightOnly|widthOnly|heightAndWidth|heightAndWidthProportionally, autoSizeReference?: topLeft|topCenter|topRight|leftCenter|center|rightCenter|bottomLeft|bottomCenter|bottomRight (the point that stays put), useMinimumHeight?: bool, minimumHeight? (pt), useMinimumWidth?: bool, minimumWidth? (pt), noLineBreaks?: bool, ignoreWrap?, balanceColumns?, columnRule?: bool, columnRuleWeight? (pt), columnRuleColor? (swatch name), columnRuleTint? (0..1), columnRuleOffset? (pt, horizontal), columnRuleTopInset? (pt), columnRuleBottomInset? (pt), baselineGrid?: {start? (pt), increment? (pt), relativeTo?: page|margin|frame|inset} (the frame's custom baseline grid; fields not given keep the frame's, or come from the document grid; null turns it off), vertical?: bool (sets the story direction of the frames' stories, as Type ▸ Story Direction), ids?}",
has_selection,
"{columns? (1..40), gutter? (pt, 0..15552), inset?: number|[t,l,b,r] (pt, each 0..15552; a list has four sides, null keeps that side), verticalJustification?: top|center|bottom|justify, paragraphSpacingLimit? (pt: Justify adds at most this between paragraphs, the rest between lines), columnsKind?: fixedNumber|fixedWidth|flexibleWidth, columnWidth? (pt, Fixed Width), firstBaseline?: ascent|capHeight|leading|xHeight|emboxHeight|fixed, firstBaselineMin? (pt), autoSize?: off|heightOnly|widthOnly|heightAndWidth|heightAndWidthProportionally, autoSizeReference?: topLeft|topCenter|topRight|leftCenter|center|rightCenter|bottomLeft|bottomCenter|bottomRight (the point that stays put), useMinimumHeight?: bool, minimumHeight? (pt), useMinimumWidth?: bool, minimumWidth? (pt), noLineBreaks?: bool, ignoreWrap?, balanceColumns?, columnRule?: bool, columnRuleWeight? (pt), columnRuleColor? (swatch name), columnRuleTint? (0..1), columnRuleOffset? (pt, horizontal), columnRuleTopInset? (pt), columnRuleBottomInset? (pt), baselineGrid?: {start? (pt), increment? (pt), relativeTo?: page|margin|frame|inset} (the frame's custom baseline grid; fields not given keep the frame's, or come from the document grid; null turns it off), vertical?: bool (sets the story direction of the frames' stories, as Type ▸ Story Direction), ids? (without ids or selected objects: the frame showing the text caret, or every frame holding part of the selected text)}",
has_selection_or_text,
text_frame_options
),
cmd!(
@@ -2707,14 +2707,45 @@ fn content_type(s: &mut Session, p: &Value) -> Result<Value> {
/// The most columns a text frame takes.
const MAX_FRAME_COLUMNS: u64 = 40;
/// The frames `object.textFrameOptions` changes when the call names none: the selected objects,
/// or with the Type tool the frame that shows the caret or every frame holding part of the
/// selected text.
pub fn text_frame_options_frames(s: &Session) -> Vec<ItemId> {
let Ok(st) = s.doc() else { return Vec::new() };
if !st.selection.items.is_empty() {
return st.selection.items.clone();
}
st.selection.text.map(|t| text_selection_frames(s, &t)).unwrap_or_default()
}
/// Text Frame Options act on the selected objects, or with the Type tool on the frames that hold
/// the caret or the selected text.
fn has_selection_or_text(s: &Session) -> std::result::Result<(), String> {
if s.active().is_some_and(|d| d.selection.text.is_some()) {
return Ok(());
}
has_selection(s)
}
fn text_frame_options(s: &mut Session, p: &Value) -> Result<Value> {
const ID: &str = "object.textFrameOptions";
let st = s.doc()?;
let mut ids = targets(s, p)?;
if ids.is_empty()
&& let Some(t) = st.selection.text
{
ids = st.doc.story(t.story).map(|s| s.frames.clone()).unwrap_or_default();
// A call that names its objects acts on those; an empty `ids` names nothing. `ids`, when
// given, wins over `id`, and a value that is not an object id is an error.
let ids = match (p.get("ids"), p.get("id")) {
(Some(v), _) => v
.as_array()
.and_then(|a| a.iter().map(|x| x.as_u64().map(ItemId)).collect::<Option<Vec<_>>>())
.ok_or_else(|| bad(ID, format!("ids must be a list of object ids, not {v}")))?,
(None, Some(v)) => vec![v.as_u64().map(ItemId).ok_or_else(|| bad(ID, format!("id must be an object id, not {v}")))?],
(None, None) => text_frame_options_frames(s),
};
// With a text caret the command runs before named objects are checked.
if let Some(gone) = ids.iter().find(|i| st.doc.item(**i).is_none()) {
return Err(bad(ID, format!("no object with id {}", gone.0)));
}
if ids.is_empty() {
return Err(bad(ID, super::NOTHING_SELECTED));
}
let ranged = |key: &str, lo: f64, hi: f64, what: &str| match p.get(key) {
None | Some(Value::Null) => Ok(None),
@@ -2811,8 +2842,10 @@ fn text_frame_options(s: &mut Session, p: &Value) -> Result<Value> {
Some(Value::String(c)) if st.doc.swatch(c).is_some() => Some(c.clone()),
Some(v) => return Err(bad(ID, format!("no swatch {v}"))),
};
let (before, revision) = (Arc::clone(&st.doc), st.revision);
let find = s.find_context.take();
let p = p.clone();
s.edit(|d, _| {
let edited = s.edit(|d, _| {
for id in &ids {
let Some(tf) = d.item_mut(*id).and_then(Item::text_frame_mut) else { continue };
let o = &mut tf.options;
@@ -2899,6 +2932,7 @@ fn text_frame_options(s: &mut Session, p: &Value) -> Result<Value> {
if fixed_width
&& ["columnsKind", "columnWidth", "columns", "gutter", "inset"].iter().any(|k| p.get(*k).is_some())
&& let Some(r) = d.item(*id).map(Item::inner_bounds)
&& ((r.width() - width).abs() >= 1e-9 || !width.is_finite())
{
let r = super::finite_rect("object.textFrameOptions", Rect::new(r.x0, r.y0, r.x0 + width, r.y1))?;
crate::autosize::resize(d, *id, r);
@@ -2910,7 +2944,84 @@ fn text_frame_options(s: &mut Session, p: &Value) -> Result<Value> {
super::text::set_story_direction(d, &stories, v);
}
Ok(json!({"changed": ids.len()}))
})
});
let changed = match edited {
Ok(v) => v,
Err(e) => {
s.find_context = find;
return Err(e);
}
};
// Options the frames already have: the document, its revision and the Find Next scope go back
// to what they were, which leaves no undo step. Only the frames and their stories are compared.
let st = s.doc_mut()?;
let same = ids.iter().all(|id| {
let (now, was) = (st.doc.item(*id), before.item(*id));
now == was && now.and_then(Item::text_frame).is_none_or(|t| st.doc.story(t.story) == before.story(t.story))
});
if same {
st.doc = before;
st.revision = revision;
s.find_context = find;
return Ok(json!({"changed": 0}));
}
Ok(changed)
}
/// The frames Text Frame Options acts on from the Type tool: the frame that shows the caret, or
/// every frame that holds part of the selected text. Text past the last frame counts as the last
/// frame's.
fn text_selection_frames(s: &Session, t: &TextSel) -> Vec<ItemId> {
let Ok(st) = s.doc() else { return Vec::new() };
let Some(story) = st.doc.story(t.story) else { return Vec::new() };
let last = story.frames.last().copied();
let cs = s.cache.get(&st.doc, t.story, None);
// In footnote text or a table cell, `anchor` and `focus` index that text: the frame the caret
// is drawn in (the placed footnote, or the cell's first non-repeated occurrence), else the
// frame that shows the footnote reference or the table's anchor character.
if let Some(c) = t.cell {
let (drawn, anchor) = match c.footnote_id() {
Some(id) => (designcraft_compose::find_note(&cs, id).map(|(fi, _)| fi), story.note_anchor(id)),
None => (designcraft_compose::find_cell(&cs, c.table, c.row, c.col).map(|(fi, ..)| fi), story.table_anchor(c.table)),
};
return drawn
.or_else(|| anchor.and_then(|a| designcraft_compose::caret(&cs, a)).map(|(fi, ..)| fi))
.and_then(|fi| cs.frames.get(fi))
.map(|f| f.frame)
.or_else(|| t.frame.filter(|f| story.frames.contains(f)))
.or(last)
.into_iter()
.collect();
}
let r = t.range();
// The frame the caret at the start is drawn in; the caret's stored frame only when no line
// holds it.
let caret_frame = || {
designcraft_compose::caret(&cs, r.start)
.and_then(|(fi, ..)| cs.frames.get(fi))
.map(|f| f.frame)
.or_else(|| t.frame.filter(|f| story.frames.contains(f) && cs.overset_at.is_none_or(|o| r.start < o)))
};
// A frame's range stops before the paragraph return that ends its last line; the return
// belongs to that frame.
let end_of = |f: &designcraft_compose::FrameText| f.range.end + usize::from(story.text.as_bytes().get(f.range.end) == Some(&b'\n'));
let mut frames: Vec<ItemId> = if t.is_caret() {
caret_frame().into_iter().collect()
} else {
cs.frames.iter().filter(|f| f.range.start < r.end && r.start < end_of(f)).map(|f| f.frame).collect()
};
// Selected text no frame holds goes with the line before it.
if frames.is_empty() {
frames.extend(caret_frame());
}
let overset = cs.overset_at.is_some_and(|o| r.end > o);
if let Some(l) = last
&& (frames.is_empty() || overset)
&& !frames.contains(&l)
{
frames.push(l);
}
frames
}
/// `object.textFrameOptions` Inset Spacing: one number for every side, or [top, left, bottom,
@@ -5015,6 +5126,7 @@ mod named_target_tests {
s.execute("file.new", &json!({})).unwrap();
let r = s.execute("frame.create", &json!({"rect": [36, 36, 300, 300], "content": "text", "text": "Hello"})).unwrap();
assert!(s.doc().unwrap().selection.items.is_empty(), "frame.create leaves a text caret");
s.execute("edit.deselectAll", &json!({})).unwrap();
let e = s.execute("object.textFrameOptions", &json!({"columns": 2})).unwrap_err().to_string();
assert!(e.contains("nothing selected"), "{e}");
s.execute("object.textFrameOptions", &json!({"ids": [r["id"]], "columns": 2})).unwrap();
@@ -5034,6 +5146,257 @@ mod named_target_tests {
}
}
#[cfg(test)]
mod type_tool_frame_options_tests {
use super::*;
use designcraft_doc::VerticalJustification;
/// One story threaded through two frames, with text in both: (first frame, second frame, story).
fn two_frame_thread(s: &mut Session) -> (ItemId, ItemId, StoryId) {
s.execute("file.new", &json!({})).unwrap();
let text = (0..40).map(|i| format!("Line {i} of the threaded story.")).collect::<Vec<_>>().join(" ");
let a = s.execute("frame.create", &json!({"rect": [36, 36, 300, 120], "content": "text", "text": text})).unwrap();
let b = s.execute("frame.create", &json!({"rect": [36, 200, 300, 700], "content": "text", "text": ""})).unwrap();
let (a, b) = (ItemId(a["id"].as_u64().unwrap()), ItemId(b["id"].as_u64().unwrap()));
s.execute("text.thread", &json!({"from": a.0, "to": b.0})).unwrap();
let sid = s.doc().unwrap().doc.item(a).and_then(Item::text_frame).unwrap().story;
(a, b, sid)
}
/// The story bytes `frame` shows.
fn shown(s: &Session, sid: StoryId, frame: ItemId) -> std::ops::Range<usize> {
let cs = designcraft_compose::compose_story(&s.doc().unwrap().doc, sid, &Default::default());
cs.frame(frame).unwrap().range.clone()
}
fn options(s: &Session, id: ItemId) -> TextFrameOptions {
s.doc().unwrap().doc.item(id).and_then(Item::text_frame).unwrap().options.clone()
}
fn undo_steps(s: &Session) -> usize {
s.doc().unwrap().history.undo.len()
}
/// With the Type tool, Text Frame Options change the frame that shows the caret, not every
/// frame of the story.
#[test]
fn a_caret_changes_the_frame_it_is_in() {
let mut s = Session::new();
let (a, b, sid) = two_frame_thread(&mut s);
let (ra, rb) = (shown(&s, sid, a), shown(&s, sid, b));
assert!(!ra.is_empty() && !rb.is_empty(), "both frames hold text: {ra:?} {rb:?}");
s.execute("text.select", &json!({"story": sid.0, "anchor": rb.start + 2})).unwrap();
assert!(s.doc().unwrap().selection.items.is_empty());
let steps = undo_steps(&s);
s.execute("object.textFrameOptions", &json!({"columns": 3, "verticalJustification": "center", "inset": 6})).unwrap();
assert_eq!(
(options(&s, b).columns, options(&s, b).vertical_justification, options(&s, b).inset),
(3, VerticalJustification::Center, [6.0; 4])
);
assert_eq!((options(&s, a).columns, options(&s, a).vertical_justification), (1, VerticalJustification::Top), "the first frame is left alone");
assert_eq!(undo_steps(&s), steps + 1, "one undo step");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(options(&s, b).columns, 1);
// A caret in the first frame changes the first frame.
s.execute("text.select", &json!({"story": sid.0, "anchor": ra.start + 2})).unwrap();
s.execute("object.textFrameOptions", &json!({"verticalJustification": "bottom"})).unwrap();
assert_eq!(
(options(&s, a).vertical_justification, options(&s, b).vertical_justification),
(VerticalJustification::Bottom, VerticalJustification::Top)
);
}
/// A caret moved to the start of the second frame keeps the first frame as its stored frame;
/// the options go to the frame the caret is drawn in.
#[test]
fn a_caret_at_a_frame_boundary_changes_the_frame_it_is_drawn_in() {
let mut s = Session::new();
let (a, b, sid) = two_frame_thread(&mut s);
let rb = shown(&s, sid, b);
let cs = designcraft_compose::compose_story(&s.doc().unwrap().doc, sid, &Default::default());
let drawn = designcraft_compose::caret(&cs, rb.start).and_then(|(fi, ..)| cs.frames.get(fi)).map(|f| f.frame);
assert_eq!(drawn, Some(b), "the caret at the boundary is drawn in the second frame");
s.doc_mut().unwrap().selection = Selection::text(TextSel { story: sid, anchor: rb.start, focus: rb.start, frame: Some(a), cell: None });
s.execute("object.textFrameOptions", &json!({"columns": 2})).unwrap();
assert_eq!((options(&s, a).columns, options(&s, b).columns), (1, 2));
}
/// Selected text that runs from one frame into the next changes both frames.
#[test]
fn selected_text_changes_every_frame_it_runs_through() {
let mut s = Session::new();
let (a, b, sid) = two_frame_thread(&mut s);
let (ra, rb) = (shown(&s, sid, a), shown(&s, sid, b));
s.execute("text.select", &json!({"story": sid.0, "anchor": ra.end - 3, "focus": rb.start + 3})).unwrap();
s.execute("object.textFrameOptions", &json!({"columns": 2})).unwrap();
assert_eq!((options(&s, a).columns, options(&s, b).columns), (2, 2));
// Text inside one frame changes that frame only.
s.execute("text.select", &json!({"story": sid.0, "anchor": rb.start + 1, "focus": rb.start + 6})).unwrap();
s.execute("object.textFrameOptions", &json!({"columns": 4})).unwrap();
assert_eq!((options(&s, a).columns, options(&s, b).columns), (2, 4));
}
/// A selected paragraph return at the end of the first frame changes the first frame.
#[test]
fn a_selected_return_at_the_end_of_a_frame_changes_that_frame() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
let text = (0..40).map(|i| format!("Paragraph {i}")).collect::<Vec<_>>().join("\n");
let a = s.execute("frame.create", &json!({"rect": [36, 36, 300, 120], "content": "text", "text": text})).unwrap();
let b = s.execute("frame.create", &json!({"rect": [36, 200, 300, 700], "content": "text", "text": ""})).unwrap();
let (a, b) = (ItemId(a["id"].as_u64().unwrap()), ItemId(b["id"].as_u64().unwrap()));
s.execute("text.thread", &json!({"from": a.0, "to": b.0})).unwrap();
let sid = s.doc().unwrap().doc.item(a).and_then(Item::text_frame).unwrap().story;
let (ra, rb) = (shown(&s, sid, a), shown(&s, sid, b));
assert_eq!(s.doc().unwrap().doc.story(sid).unwrap().text.as_bytes()[ra.end], b'\n', "the first frame ends before a return");
assert_eq!(rb.start, ra.end + 1, "the second frame starts after it");
s.execute("text.select", &json!({"story": sid.0, "anchor": ra.end, "focus": ra.end + 1})).unwrap();
s.execute("object.textFrameOptions", &json!({"columns": 2})).unwrap();
assert_eq!((options(&s, a).columns, options(&s, b).columns), (2, 1));
// From that return into the second frame, with the first frame back as it was: both frames.
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!((shown(&s, sid, a), shown(&s, sid, b)), (ra.clone(), rb.clone()));
s.execute("text.select", &json!({"story": sid.0, "anchor": ra.end, "focus": rb.start + 3})).unwrap();
s.execute("object.textFrameOptions", &json!({"columns": 3})).unwrap();
assert_eq!((options(&s, a).columns, options(&s, b).columns), (3, 3));
}
/// An empty `ids` names no frame, so it does not fall back to the caret's frame.
#[test]
fn empty_ids_with_a_caret_is_an_error() {
let mut s = Session::new();
let (a, b, sid) = two_frame_thread(&mut s);
s.execute("text.select", &json!({"story": sid.0, "anchor": 2})).unwrap();
let before = s.doc().unwrap().doc.clone();
let e = s.execute("object.textFrameOptions", &json!({"ids": [], "columns": 3})).unwrap_err().to_string();
assert!(e.contains("nothing selected"), "{e}");
// An id that is not in the document is refused too.
let e = s.execute("object.textFrameOptions", &json!({"ids": [99999, b.0], "columns": 3})).unwrap_err().to_string();
assert!(e.contains("no object with id 99999"), "{e}");
assert!(std::sync::Arc::ptr_eq(&before, &s.doc().unwrap().doc), "nothing changed");
assert_eq!((options(&s, a).columns, options(&s, b).columns), (1, 1));
}
/// An `ids` that is not a list of object ids is refused, not read as the selected frame or the
/// caret's frame.
#[test]
fn malformed_ids_are_an_error() {
let mut s = Session::new();
let (a, b, sid) = two_frame_thread(&mut s);
s.execute("selection.set", &json!({"ids": [b.0]})).unwrap();
let before = s.doc().unwrap().doc.clone();
for p in [json!({"ids": "bad", "columns": 2}), json!({"ids": [b.0, "x"], "columns": 2}), json!({"ids": null, "columns": 2})] {
let e = s.execute("object.textFrameOptions", &p).unwrap_err().to_string();
assert!(e.contains("ids must be a list of object ids"), "{p}: {e}");
}
s.execute("text.select", &json!({"story": sid.0, "anchor": 2})).unwrap();
let e = s.execute("object.textFrameOptions", &json!({"ids": "bad", "columns": 2})).unwrap_err().to_string();
assert!(e.contains("ids must be a list of object ids"), "with a caret: {e}");
assert!(std::sync::Arc::ptr_eq(&before, &s.doc().unwrap().doc), "nothing changed");
assert_eq!((options(&s, a).columns, options(&s, b).columns), (1, 1));
}
/// Options the frame already has change nothing and add no undo step.
#[test]
fn unchanged_options_add_no_undo_step() {
let mut s = Session::new();
let (_, b, sid) = two_frame_thread(&mut s);
let rb = shown(&s, sid, b);
s.execute("text.select", &json!({"story": sid.0, "anchor": rb.start + 2})).unwrap();
let steps = undo_steps(&s);
let (before, revision) = (s.doc().unwrap().doc.clone(), s.doc().unwrap().revision);
let r = s.execute("object.textFrameOptions", &json!({"columns": 1, "verticalJustification": "top", "inset": 0})).unwrap();
assert_eq!(r["changed"], 0);
assert!(std::sync::Arc::ptr_eq(&before, &s.doc().unwrap().doc), "nothing changed");
assert_eq!(s.doc().unwrap().revision, revision, "the revision stays");
assert_eq!(undo_steps(&s), steps);
// The same holds for selected frames, Fixed Width columns included.
s.execute("selection.set", &json!({"ids": [b.0]})).unwrap();
s.execute("object.textFrameOptions", &json!({"gutter": options(&s, b).gutter})).unwrap();
assert_eq!(undo_steps(&s), steps);
let fixed = json!({"columnsKind": "fixedWidth", "columnWidth": 100.3, "columns": 2, "gutter": 12.1});
s.execute("object.textFrameOptions", &fixed).unwrap();
assert_eq!(undo_steps(&s), steps + 1);
assert_eq!(s.execute("object.textFrameOptions", &fixed).unwrap()["changed"], 0);
assert_eq!(undo_steps(&s), steps + 1, "the same Fixed Width options again add no undo step");
}
/// A caret in footnote text changes the frame that shows the footnote, with or without a
/// stored frame on the caret.
#[test]
fn a_caret_in_a_footnote_changes_the_frame_that_shows_it() {
for (in_second, stored) in [(false, None), (true, None), (false, Some(true))] {
let mut s = Session::new();
let (a, b, sid) = two_frame_thread(&mut s);
let r = shown(&s, sid, if in_second { b } else { a });
s.execute("text.select", &json!({"story": sid.0, "anchor": r.start + 2})).unwrap();
s.execute("footnote.insert", &json!({"text": "Note."})).unwrap();
let mut t = s.doc().unwrap().selection.text.unwrap();
assert!(t.cell.and_then(|c| c.footnote_id()).is_some(), "the caret is in the footnote: {t:?}");
if let Some(second) = stored {
t.frame = Some(if second { b } else { a });
s.doc_mut().unwrap().selection = Selection::text(t);
}
s.execute("object.textFrameOptions", &json!({"columns": 2})).unwrap();
let want = if in_second { (1, 2) } else { (2, 1) };
assert_eq!((options(&s, a).columns, options(&s, b).columns), want, "footnote in the second frame: {in_second}, stored frame: {stored:?}");
}
}
/// A caret in a table cell changes the frame that shows the cell, with or without a stored
/// frame on the caret.
#[test]
fn a_caret_in_a_table_cell_changes_the_frame_that_shows_it() {
for (in_second, stored) in [(false, None), (true, None), (false, Some(true))] {
let mut s = Session::new();
let (a, b, sid) = two_frame_thread(&mut s);
let r = shown(&s, sid, if in_second { b } else { a });
s.execute("text.select", &json!({"story": sid.0, "anchor": r.start + 2})).unwrap();
s.execute("table.insert", &json!({"rows": 1, "cols": 1})).unwrap();
let mut t = s.doc().unwrap().selection.text.unwrap();
assert!(t.cell.is_some_and(|c| c.footnote_id().is_none()), "the caret is in the cell: {t:?}");
if let Some(second) = stored {
t.frame = Some(if second { b } else { a });
s.doc_mut().unwrap().selection = Selection::text(t);
}
s.execute("object.textFrameOptions", &json!({"columns": 2})).unwrap();
let want = if in_second { (1, 2) } else { (2, 1) };
assert_eq!((options(&s, a).columns, options(&s, b).columns), want, "table in the second frame: {in_second}, stored frame: {stored:?}");
}
}
/// A caret in a repeated footer row is drawn in the footer's own occurrence at the end of the
/// table: that frame changes, not the earlier frame that shows a repeat of the footer.
#[test]
fn a_caret_in_a_repeated_footer_changes_the_frame_with_the_footer_itself() {
let mut s = Session::new();
let (a, b, sid) = two_frame_thread(&mut s);
let ra = shown(&s, sid, a);
s.execute("text.select", &json!({"story": sid.0, "anchor": ra.start + 2})).unwrap();
s.execute("table.insert", &json!({"rows": 15, "cols": 1, "footerRows": 1})).unwrap();
s.execute("table.options", &json!({"repeatFooter": true})).unwrap();
let t = s.doc().unwrap().selection.text.unwrap();
let table = t.cell.unwrap().table;
let footer = s.doc().unwrap().doc.story(sid).unwrap().tables.get(&table).unwrap().nrows() - 1;
let cs = designcraft_compose::compose_story(&s.doc().unwrap().doc, sid, &Default::default());
let placed = |f: ItemId| {
cs.frame(f)
.unwrap()
.tables
.iter()
.filter(|tf| tf.table == table)
.filter_map(|tf| tf.cell(footer, 0))
.map(|c| c.repeated)
.collect::<Vec<_>>()
};
assert_eq!((placed(a), placed(b)), (vec![true], vec![false]), "the footer repeats in the first frame and ends the table in the second");
s.doc_mut().unwrap().selection =
Selection::text(TextSel { cell: Some(designcraft_doc::CellAddr { table, row: footer, col: 0 }), anchor: 0, focus: 0, frame: None, ..t });
s.execute("object.textFrameOptions", &json!({"columns": 2})).unwrap();
assert_eq!((options(&s, a).columns, options(&s, b).columns), (1, 2));
}
}
#[cfg(test)]
mod column_rule_tests {
use super::*;
+5
View File
@@ -414,6 +414,10 @@ pub struct Session {
pub clipboard_origin: f64,
/// Crash-recovery folder (the app sets it; saving or closing a document removes its entry).
pub recovery_dir: Option<std::path::PathBuf>,
/// This session's number for the background recovery writer, which returns each result to
/// the session that queued it.
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
pub(crate) recovery_owner: recovery::Owner,
/// Copied text with its formatting (a frameless story slice), its plain text, and what pasting
/// it needs from its document: a copy holding only the stories its anchored text frames show
/// (and theirs) and the graphics the text and those stories place.
@@ -479,6 +483,7 @@ impl Session {
clipboard: None,
clipboard_origin: 0.0,
recovery_dir: None,
recovery_owner: recovery::Owner::new(),
text_clipboard: None,
link_checks: Default::default(),
ui_requests: vec![],
File diff suppressed because it is too large. Load diff
+749 -6
View File
@@ -1,5 +1,12 @@
use super::*;
/// [`super::discard`] as the session that wrote or recovered the entry, if one did.
fn discard(dir: &Path, uid: u64) {
let key = directory_key(dir).ok().map(|key| (key, uid));
let owner = key.and_then(|key| WRITTEN.lock().unwrap_or_else(std::sync::PoisonError::into_inner).get(&key).copied());
super::discard(dir, uid, owner.unwrap_or(0));
}
fn dirty_session() -> Session {
let mut session = Session::new();
session.execute("file.new", &json!({})).unwrap();
@@ -126,6 +133,727 @@ fn recovery_data_is_private_to_the_user() {
}
}
/// The recovery writer is one thread for the whole process, and its results go to whichever
/// session polls it: tests that submit to it take turns, so one test's write or error is never
/// drained by another.
static BACKGROUND: std::sync::Mutex<()> = std::sync::Mutex::new(());
fn background() -> std::sync::MutexGuard<'static, ()> {
BACKGROUND.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
/// Wait for the background writer to have nothing left, then read `file.recovery.progress` as the
/// app does at the end of a frame.
fn finished_writes(s: &mut Session) -> usize {
testing::wait_until_idle();
let v = s.execute("file.recovery.progress", &json!({})).unwrap();
assert_eq!(v["errors"], json!([]), "{v}");
assert_eq!(v["busy"], false, "{v}");
v["written"].as_u64().unwrap_or(0) as usize
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_background_save_returns_while_its_write_is_held() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
let uid = s.docs[0].uid;
let (file, _) = files(dir.path(), uid);
let held = testing::hold_next_write(dir.path());
let queued = s.execute("file.recovery.save", &json!({"background": true})).unwrap();
assert!(!held.ran_here(), "the write ran on the calling thread");
assert_eq!(queued["queued"], 1, "{queued}");
// The writer thread is stopped at the start of the write, and the session goes on.
held.wait_until_held();
let v = s.execute("file.recovery.progress", &json!({})).unwrap();
assert_eq!(v["busy"], true, "{v}");
s.execute("frame.create", &json!({"rect": [20, 20, 60, 60]})).unwrap();
assert!(!file.exists(), "nothing is published while the write is held");
held.release();
assert_eq!(finished_writes(&mut s), 1);
assert!(file.exists());
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_document_saved_while_its_write_is_held_leaves_no_snapshot() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
let uid = s.docs[0].uid;
let held = testing::hold_next_write(dir.path());
s.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
let saved = dir.path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
held.release();
// Before the session takes the result: a crash now must not find the stale snapshot.
testing::wait_until_idle();
assert!(!files(dir.path(), uid).0.exists(), "the stale snapshot was not published");
assert!(!files(dir.path(), uid).1.exists(), "nor its metadata");
assert_eq!(finished_writes(&mut s), 0);
assert!(list(dir.path()).is_empty());
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_document_saved_while_its_write_to_a_named_folder_is_held_leaves_no_snapshot() {
// A folder given to `file.recovery.save` is not the session's, and is not in the document's
// entries until the write's result is taken.
let _turn = background();
let named = tempfile::tempdir().unwrap();
let mut s = dirty_session();
let uid = s.docs[0].uid;
let held = testing::hold_next_write(named.path());
let queued = s.execute("file.recovery.save", &json!({"background": true, "dir": named.path().to_string_lossy()})).unwrap();
assert_eq!(queued["queued"], 1, "{queued}");
held.wait_until_held();
let saved = named.path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
held.release();
// Before the session takes the result: a crash now must not find the stale snapshot.
testing::wait_until_idle();
assert!(!files(named.path(), uid).0.exists(), "the stale snapshot was not published");
assert_eq!(finished_writes(&mut s), 0);
assert!(list(named.path()).is_empty());
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn saving_removes_a_finished_write_to_a_named_folder_whose_result_was_not_taken() {
let _turn = background();
let named = tempfile::tempdir().unwrap();
let mut s = dirty_session();
let uid = s.docs[0].uid;
s.execute("file.recovery.save", &json!({"background": true, "dir": named.path().to_string_lossy()})).unwrap();
testing::wait_until_idle();
assert!(files(named.path(), uid).0.exists(), "the write finished");
let saved = named.path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
assert!(!files(named.path(), uid).0.exists(), "Save removed the snapshot before its result was taken");
// Edited again before the result is taken: the removed snapshot is not its checkpoint.
s.execute("frame.create", &json!({"rect": [20, 20, 60, 60]})).unwrap();
assert_eq!(finished_writes(&mut s), 0);
assert!(!s.docs[0].recovery_entries.iter().any(|(d, _)| same_directory(d, named.path())), "no checkpoint for a removed snapshot");
assert!(list(named.path()).is_empty());
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn opening_recovery_leaves_a_finished_background_write_whose_result_was_not_taken() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
let uid = s.docs[0].uid;
s.execute("file.recovery.save", &json!({"background": true})).unwrap();
testing::wait_until_idle();
assert!(files(dir.path(), uid).0.exists(), "the write finished");
assert!(open(&mut s, dir.path()).unwrap().is_empty(), "the live document's own snapshot is not recovered");
assert_eq!(s.docs.len(), 1);
assert_eq!(finished_writes(&mut s), 1);
assert_eq!(list(dir.path()).len(), 1);
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn an_edit_after_a_save_is_written_after_the_cancelled_write_stops() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
let uid = s.docs[0].uid;
let held = testing::hold_next_write(dir.path());
s.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
let saved = tempfile::tempdir().unwrap();
s.execute("file.saveAs", &json!({"path": saved.path().join("saved.designcraft").to_string_lossy()})).unwrap();
s.execute("frame.create", &json!({"rect": [20, 20, 60, 60]})).unwrap();
// The held write was cancelled: the new edit is queued behind it instead of waiting for the
// next timer tick.
let queued = s.execute("file.recovery.save", &json!({"background": true})).unwrap();
assert_eq!(queued["queued"], 1, "{queued}");
held.release();
assert_eq!(finished_writes(&mut s), 1);
let mut reopened = Session::new();
assert_eq!(open(&mut reopened, dir.path()).unwrap().len(), 1);
assert_eq!(reopened.doc().unwrap().doc.spreads[0].items.len(), 2, "the snapshot after the edit was written");
discard(dir.path(), reopened.doc().unwrap().uid);
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_background_result_goes_to_the_session_that_queued_it() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut queued_by = dirty_session();
queued_by.recovery_dir = Some(dir.path().to_path_buf());
let uid = queued_by.docs[0].uid;
let mut other = dirty_session();
queued_by.execute("file.recovery.save", &json!({"background": true})).unwrap();
testing::wait_until_idle();
// Another session has none of these documents: it must neither take the result nor remove
// the snapshot as if its document had been closed.
let v = other.execute("file.recovery.progress", &json!({})).unwrap();
assert_eq!(v["written"], 0, "{v}");
assert!(files(dir.path(), uid).0.exists(), "the snapshot is still there");
assert_eq!(finished_writes(&mut queued_by), 1);
assert!(queued_by.docs[0].recovery_entries.iter().any(|(d, u)| *u == uid && same_directory(d, dir.path())), "the checkpoint is recorded");
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn saving_in_one_session_leaves_another_sessions_write_alone() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut queued_by = dirty_session();
queued_by.recovery_dir = Some(dir.path().to_path_buf());
let uid = queued_by.docs[0].uid;
// The same uid in another session (recovered documents keep the uids of their entries).
let mut other = dirty_session();
other.docs[0].uid = uid;
let held = testing::hold_next_write(dir.path());
queued_by.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
let elsewhere = tempfile::tempdir().unwrap();
other.execute("file.saveAs", &json!({"path": elsewhere.path().join("other.designcraft").to_string_lossy()})).unwrap();
held.release();
assert_eq!(finished_writes(&mut queued_by), 1);
assert!(files(dir.path(), uid).0.exists(), "the other session's save did not cancel this write");
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn saving_in_one_session_leaves_another_sessions_write_to_the_same_folder_alone() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut queued_by = dirty_session();
queued_by.recovery_dir = Some(dir.path().to_path_buf());
let uid = queued_by.docs[0].uid;
// The same uid and recovery folder in another session.
let mut other = dirty_session();
other.recovery_dir = Some(dir.path().to_path_buf());
other.docs[0].uid = uid;
let held = testing::hold_next_write(dir.path());
queued_by.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
let elsewhere = tempfile::tempdir().unwrap();
other.execute("file.saveAs", &json!({"path": elsewhere.path().join("other.designcraft").to_string_lossy()})).unwrap();
assert!(!worker::cancelled(dir.path(), uid), "the other session's save cancelled this write");
held.release();
assert_eq!(finished_writes(&mut queued_by), 1);
assert!(files(dir.path(), uid).0.exists(), "this session's snapshot was kept");
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_write_now_in_one_session_leaves_another_sessions_write_of_the_same_uid_alone() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut queued_by = dirty_session();
queued_by.recovery_dir = Some(dir.path().to_path_buf());
let uid = queued_by.docs[0].uid;
// The same uid in another session, with two objects instead of one.
let mut other = dirty_session();
other.docs[0].uid = uid;
other.execute("frame.create", &json!({"rect": [20, 20, 60, 60]})).unwrap();
let held = testing::hold_next_write(dir.path());
queued_by.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
let err = save(&other, dir.path()).unwrap_err();
assert!(err.to_string().contains("still being written"), "{err}");
let err = other.execute("file.recovery.save", &json!({"dir": dir.path().to_string_lossy()})).unwrap_err();
assert!(err.to_string().contains("still being written"), "{err}");
assert!(!worker::cancelled(dir.path(), uid), "the other session's write now cancelled this write");
held.release();
assert_eq!(finished_writes(&mut queued_by), 1);
let mut reopened = Session::new();
assert_eq!(open(&mut reopened, dir.path()).unwrap().len(), 1);
assert_eq!(reopened.doc().unwrap().doc.spreads[0].items.len(), 1, "the queued session's snapshot was kept");
discard(dir.path(), reopened.doc().unwrap().uid);
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn no_other_sessions_write_of_the_uid_is_queued_during_a_write_now() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let writing = dirty_session();
let uid = writing.docs[0].uid;
let mut other = dirty_session();
other.recovery_dir = Some(dir.path().to_path_buf());
other.docs[0].uid = uid;
let now = worker::write_now(dir.path(), uid, writing.recovery_owner.0).expect("nothing else is in flight");
let queued = other.execute("file.recovery.save", &json!({"background": true})).unwrap();
assert_eq!(queued["queued"], 0, "another session's write was queued during the write now: {queued}");
assert!(worker::write_now(dir.path(), uid, other.recovery_owner.0).is_none(), "a second write now of the uid started");
drop(now);
let queued = other.execute("file.recovery.save", &json!({"background": true})).unwrap();
assert_eq!(queued["queued"], 1, "{queued}");
assert_eq!(finished_writes(&mut other), 1);
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_write_now_cancels_a_background_write_to_the_same_folder_spelled_another_way() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
std::fs::create_dir(dir.path().join("sub")).unwrap();
let spelled = dir.path().join("sub").join("..");
let mut s = dirty_session();
s.recovery_dir = Some(spelled.clone());
let uid = s.docs[0].uid;
let held = testing::hold_next_write(&spelled);
s.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
// The newer state, written now under the folder's plain name.
s.execute("frame.create", &json!({"rect": [20, 20, 60, 60]})).unwrap();
s.execute("file.recovery.save", &json!({"dir": dir.path().to_string_lossy()})).unwrap();
assert!(worker::cancelled(&spelled, uid), "the older write is cancelled");
held.release();
testing::wait_until_idle();
let _ = s.execute("file.recovery.progress", &json!({})).unwrap();
let mut reopened = Session::new();
assert_eq!(open(&mut reopened, dir.path()).unwrap().len(), 1);
assert_eq!(reopened.doc().unwrap().doc.spreads[0].items.len(), 2, "the newer snapshot was kept");
discard(dir.path(), reopened.doc().unwrap().uid);
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn queued_background_writes_count_toward_the_checkpoint_limit() {
let _turn = background();
let mut s = dirty_session();
let folders: Vec<tempfile::TempDir> = (0..=MAX_RECOVERY_ENTRIES).map(|_| tempfile::tempdir().unwrap()).collect();
// The first write is held, so every later one is still queued when the next is asked for.
let held = testing::hold_next_write(folders[0].path());
for folder in &folders[..MAX_RECOVERY_ENTRIES] {
let queued = s.execute("file.recovery.save", &json!({"background": true, "dir": folder.path().to_string_lossy()})).unwrap();
assert_eq!(queued["queued"], 1, "{queued}");
}
let over = folders[MAX_RECOVERY_ENTRIES].path();
let err = s.execute("file.recovery.save", &json!({"background": true, "dir": over.to_string_lossy()})).unwrap_err();
assert!(err.to_string().contains("too many recovery checkpoints"), "{err}");
// Saving cancels the queued writes: they no longer count once the document changes again.
let saved = folders[0].path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
s.execute("frame.create", &json!({"rect": [20, 20, 60, 60]})).unwrap();
let queued = s.execute("file.recovery.save", &json!({"background": true, "dir": over.to_string_lossy()})).unwrap();
assert_eq!(queued["queued"], 1, "{queued}");
held.release();
assert_eq!(finished_writes(&mut s), 1, "only the write queued after the save is a checkpoint");
assert_eq!(list(over).len(), 1);
let uid = s.docs[0].uid;
for folder in &folders {
discard(folder.path(), uid);
}
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn results_for_a_session_that_is_gone_are_not_kept() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut gone = dirty_session();
gone.recovery_dir = Some(dir.path().to_path_buf());
let owner = gone.recovery_owner.0;
gone.execute("file.recovery.save", &json!({"background": true})).unwrap();
testing::wait_until_idle();
drop(gone);
let mut other = dirty_session();
other.execute("file.recovery.progress", &json!({})).unwrap();
let writer = worker::started().unwrap();
let kept = writer.undelivered.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
assert!(!kept.iter().any(|d| d.owner == owner), "a result nobody can take was kept");
}
#[test]
fn a_background_save_rejects_a_background_that_is_not_true_or_false() {
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
let err = s.execute("file.recovery.save", &json!({"background": "yes"})).unwrap_err();
assert!(err.to_string().contains("`background` must be true or false"), "{err}");
assert!(list(dir.path()).is_empty(), "nothing was written");
}
#[test]
fn a_background_save_writes_recovery_data_the_app_can_recover() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
// The timer's call: the interface thread does not wait for the deflate or the file writes.
let queued = s.execute("file.recovery.save", &json!({"background": true})).unwrap();
assert_eq!(queued["queued"], 1, "{queued}");
assert_eq!(finished_writes(&mut s), 1);
assert_eq!(list(dir.path()).len(), 1);
assert!(s.docs[0].recovery_entries.iter().any(|(d, _)| same_directory(d, dir.path())), "the checkpoint is recorded");
// Recovering it gives the unsaved edits back.
let mut reopened = Session::new();
assert_eq!(open(&mut reopened, dir.path()).unwrap().len(), 1);
assert_eq!(reopened.doc().unwrap().doc.spreads[0].items.len(), 1);
assert!(reopened.doc().unwrap().is_dirty());
discard(dir.path(), reopened.doc().unwrap().uid);
}
#[test]
fn a_snapshot_that_finishes_after_the_save_is_dropped() {
// A write of a large document runs for seconds: the user can save while it does. The saved
// document's checkpoint is consumed then, and the write must not put a stale snapshot back.
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
let uid = s.docs[0].uid;
// The snapshot the writer took before the save.
let entry = Snapshot::of(&prepare_save(&s, dir.path()).unwrap(), dir.path(), &s.docs[0]);
let saved = dir.path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
assert!(!s.docs[0].is_dirty());
// The write lands after the save.
let written = write_snapshot(&entry, || false);
assert!(written.published && written.error.is_none(), "the snapshot landed");
let (file, _) = files(dir.path(), uid);
assert!(file.exists());
assert!(!record_checkpoint(&mut s, dir.path().to_path_buf(), uid), "a saved document records no checkpoint");
assert!(!file.exists(), "its snapshot is not left to be recovered");
assert!(list(dir.path()).is_empty());
// A document still unsaved does record one.
s.execute("frame.create", &json!({"rect": [10, 10, 50, 50]})).unwrap();
let entry = Snapshot::of(&prepare_save(&s, dir.path()).unwrap(), dir.path(), &s.docs[0]);
let written = write_snapshot(&entry, || false);
assert!(written.published && written.error.is_none(), "the second snapshot landed");
assert!(record_checkpoint(&mut s, dir.path().to_path_buf(), uid));
assert!(s.docs[0].recovery_entries.iter().any(|(d, u)| *u == uid && d == dir.path()));
}
#[test]
fn a_shared_folders_entry_is_only_its_writing_sessions() {
// A recovered entry keeps the uid it was written under, which a document of another session
// in the same process can have.
let dir = tempfile::tempdir().unwrap();
let writer = dirty_session();
let uid = writer.docs[0].uid;
assert_eq!(save(&writer, dir.path()).unwrap(), 1);
let (file, _) = files(dir.path(), uid);
let snapshot = std::fs::read(&file).unwrap();
// Another session's clean document with that uid: its discard leaves the entry alone.
let mut clean = Session::new();
clean.execute("file.new", &json!({})).unwrap();
clean.docs[0].uid = uid;
assert_eq!(save(&clean, dir.path()).unwrap(), 0);
assert!(file.exists(), "another session's discard removed the entry");
// Another session's edited document with that uid: it does not write over the entry.
let mut edited = dirty_session();
edited.docs[0].uid = uid;
assert!(save(&edited, dir.path()).is_err());
assert_eq!(std::fs::read(&file).unwrap(), snapshot, "another session wrote over the entry");
super::discard(dir.path(), uid, writer.recovery_owner.0);
assert!(!file.exists(), "the writing session removes its entry");
}
#[test]
fn a_snapshot_queued_as_the_sessions_own_is_recorded_when_it_lands() {
// A write taken while the shared folder's entry was this session's, published after a cleanup
// dropped that record: Save and Close must still remove what it put there.
let dir = tempfile::tempdir().unwrap();
let s = dirty_session();
let uid = s.docs[0].uid;
let owner = s.recovery_owner.0;
assert_eq!(save(&s, dir.path()).unwrap(), 1);
let entry = Snapshot::of(&prepare_save(&s, dir.path()).unwrap(), dir.path(), &s.docs[0]);
assert!(entry.own);
super::discard(dir.path(), uid, owner);
let (file, _) = files(dir.path(), uid);
assert!(!file.exists());
let written = write_snapshot(&entry, || false);
assert!(written.published && written.error.is_none(), "the snapshot landed");
super::discard(dir.path(), uid, owner);
assert!(!file.exists(), "the snapshot it wrote is the session's to remove");
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_snapshot_whose_metadata_failed_is_still_the_documents_to_remove() {
// The primary document is the recovery data; its metadata is optional. A metadata failure
// must not leave the published snapshot untracked, or Save and Close would not remove it and
// it would stay in the folder for ever.
let root = tempfile::tempdir().unwrap();
let dir = run_dir(root.path()).unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.clone());
let uid = s.docs[0].uid;
let (document, metadata) = files(&dir, uid);
// The folder is this run's own, so the entry is its own; a folder takes the metadata's name,
// which makes the optional write fail after the primary landed.
std::fs::create_dir(&metadata).unwrap();
let err = save_tracked(&mut s, &dir).unwrap_err();
assert!(err.to_string().contains(&metadata.display().to_string()), "{err}");
assert!(document.exists(), "the primary landed");
assert!(s.docs[0].recovery_entries.iter().any(|(d, u)| *u == uid && same_directory(d, &dir)), "and is tracked");
// Saving the document removes the snapshot this run wrote.
let saved = root.path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
assert!(!document.exists(), "Save removed the snapshot");
assert!(s.docs[0].recovery_entries.is_empty());
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_snapshot_whose_folder_sync_failed_is_still_the_documents_to_remove() {
// The rename put the snapshot in place before the folder sync failed: it is tracked, so Save
// removes it.
let root = tempfile::tempdir().unwrap();
let dir = run_dir(root.path()).unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.clone());
let uid = s.docs[0].uid;
let (document, _) = files(&dir, uid);
testing::fail_next_sync(&dir);
let err = save_tracked(&mut s, &dir).unwrap_err();
assert!(err.to_string().contains("sync failed"), "{err}");
assert!(document.exists(), "the snapshot landed");
assert!(s.docs[0].recovery_entries.iter().any(|(d, u)| *u == uid && same_directory(d, &dir)), "and is tracked");
let saved = root.path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
assert!(!document.exists(), "Save removed the snapshot");
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_document_undone_to_its_saved_state_while_its_write_is_held_leaves_no_snapshot() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
let uid = s.docs[0].uid;
let held = testing::hold_next_write(dir.path());
s.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
s.execute("edit.undo", &json!({})).unwrap();
assert!(!s.docs[0].is_dirty(), "back to the state it had");
// A save of recovery data now drops the clean document's checkpoint, and the held write of
// the older state must not publish after it.
save(&s, dir.path()).unwrap();
held.release();
testing::wait_until_idle();
assert!(!files(dir.path(), uid).0.exists(), "the older snapshot was not published");
let _ = s.execute("file.recovery.progress", &json!({}));
assert!(list(dir.path()).is_empty());
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_document_undone_to_its_saved_state_loses_the_snapshot_a_finished_write_left_in_another_folder() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let other = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(other.path().to_path_buf());
let uid = s.docs[0].uid;
s.execute("file.recovery.save", &json!({"background": true})).unwrap();
// Written, but its result not yet taken by the session.
testing::wait_until_idle();
assert!(files(other.path(), uid).0.exists());
s.execute("edit.undo", &json!({})).unwrap();
save(&s, dir.path()).unwrap();
assert!(!files(other.path(), uid).0.exists(), "the snapshot of the older state is removed");
let _ = s.execute("file.recovery.progress", &json!({}));
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_clean_document_leaves_another_sessions_write_queued_behind_its_own() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut a = dirty_session();
a.recovery_dir = Some(dir.path().to_path_buf());
let uid = a.docs[0].uid;
let mut b = dirty_session();
b.recovery_dir = Some(dir.path().to_path_buf());
b.docs[0].uid = uid;
b.execute("frame.create", &json!({"rect": [20, 20, 60, 60]})).unwrap();
let held = testing::hold_next_write(dir.path());
a.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
// A write now cancels the held one. The other session does not write over the entry it left.
a.execute("file.recovery.save", &json!({"dir": dir.path().to_string_lossy()})).unwrap();
let err = b.execute("file.recovery.save", &json!({"background": true})).unwrap_err();
assert!(err.to_string().contains("did not write"), "{err}");
a.execute("edit.undo", &json!({})).unwrap();
assert!(!a.docs[0].is_dirty());
save(&a, dir.path()).unwrap();
// Once that entry is gone, the other session's write is queued to follow the held one.
b.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.release();
assert_eq!(finished_writes(&mut b), 1, "the other session's write ran");
let mut reopened = Session::new();
assert_eq!(open(&mut reopened, dir.path()).unwrap().len(), 1);
assert_eq!(reopened.doc().unwrap().doc.spreads[0].items.len(), 2, "its snapshot was kept");
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_background_recovery_write_reports_another_sessions_held_write() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut first = dirty_session();
first.recovery_dir = Some(dir.path().to_path_buf());
let uid = first.docs[0].uid;
let mut second = dirty_session();
second.recovery_dir = Some(dir.path().to_path_buf());
second.docs[0].uid = uid;
second.execute("frame.create", &json!({"rect": [20, 20, 60, 60]})).unwrap();
let held = testing::hold_next_write(dir.path());
first.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
let err = second.execute("file.recovery.save", &json!({"background": true})).unwrap_err();
assert!(err.to_string().contains("another session"), "{err}");
held.release();
assert_eq!(finished_writes(&mut first), 1);
assert!(files(dir.path(), uid).0.exists(), "the first session's recovery file remains intact");
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_clean_document_in_another_session_leaves_this_sessions_write_alone() {
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut queued_by = dirty_session();
queued_by.recovery_dir = Some(dir.path().to_path_buf());
let uid = queued_by.docs[0].uid;
// The same uid, clean, in another session.
let mut other = Session::new();
other.execute("file.new", &json!({})).unwrap();
other.docs[0].uid = uid;
assert!(!other.docs[0].is_dirty());
let held = testing::hold_next_write(dir.path());
queued_by.execute("file.recovery.save", &json!({"background": true})).unwrap();
held.wait_until_held();
save(&other, dir.path()).unwrap();
held.release();
assert_eq!(finished_writes(&mut queued_by), 1);
assert!(files(dir.path(), uid).0.exists(), "the other session's save did not cancel this write");
discard(dir.path(), uid);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_background_snapshot_whose_metadata_failed_is_still_the_documents_to_remove() {
// The background writer's result must be applied the same way: a published primary is the
// document's snapshot even when its optional metadata fails.
let _turn = background();
let root = tempfile::tempdir().unwrap();
let dir = run_dir(root.path()).unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.clone());
let uid = s.docs[0].uid;
let (document, metadata) = files(&dir, uid);
std::fs::create_dir(&metadata).unwrap();
let queued = s.execute("file.recovery.save", &json!({"background": true})).unwrap();
assert_eq!(queued["queued"], 1, "{queued}");
testing::wait_until_idle();
let v = s.execute("file.recovery.progress", &json!({})).unwrap();
assert_eq!(v["busy"], false, "{v}");
let reported = v["errors"].as_array().and_then(|errors| errors.first()).and_then(Value::as_str).map(str::to_string);
let reported = reported.expect("the metadata failure is reported");
assert!(reported.contains(&metadata.display().to_string()), "{reported}");
assert!(document.exists(), "the primary landed");
assert!(s.docs[0].recovery_entries.iter().any(|(d, u)| *u == uid && same_directory(d, &dir)), "and is tracked");
// Saving the document removes the snapshot this run wrote.
let saved = root.path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
assert!(!document.exists(), "Save removed the snapshot");
}
#[test]
fn a_write_cancelled_midway_publishes_nothing() {
// Save/Revert/Close during a write marks it cancelled; the snapshot must not land after it,
// even if the app crashes before the next interface frame discards it.
let dir = tempfile::tempdir().unwrap();
let s = dirty_session();
let entry = Snapshot::of(&prepare_save(&s, dir.path()).unwrap(), dir.path(), &s.docs[0]);
let written = write_snapshot(&entry, || true);
assert!(!written.published && written.error.is_none(), "a cancelled write is not an error");
assert!(list(dir.path()).is_empty(), "a cancelled write leaves no snapshot");
assert!(!files(dir.path(), entry.uid).0.exists(), "nor its document");
assert!(!files(dir.path(), entry.uid).1.exists(), "nor its metadata");
// The temporary file it was written to is dropped, not left behind.
assert!(
std::fs::read_dir(dir.path()).unwrap().all(|e| e.is_ok_and(|e| !e.file_name().to_string_lossy().starts_with(".designcraft-recovery-"))),
"no temporary file is left"
);
}
#[test]
fn a_cancel_stops_a_write_before_the_package_is_finished() {
let dir = tempfile::tempdir().unwrap();
let s = dirty_session();
let entry = Snapshot::of(&prepare_save(&s, dir.path()).unwrap(), dir.path(), &s.docs[0]);
// Cancelled once the write has started: the first check passes, every later one fails.
let checks = std::cell::Cell::new(0);
let written = write_snapshot(&entry, || {
checks.set(checks.get() + 1);
checks.get() > 1
});
assert!(!written.published && written.error.is_none(), "a stopped write is not an error");
assert!(checks.get() >= 2, "the write checked again before it finished");
assert!(!files(dir.path(), entry.uid).0.exists(), "nothing was published");
assert!(
std::fs::read_dir(dir.path()).unwrap().all(|e| e.is_ok_and(|e| !e.file_name().to_string_lossy().starts_with(".designcraft-recovery-"))),
"no temporary file is left"
);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn only_a_queued_write_is_cancelled() {
// A mark for a document with no write in flight would stay in the writer's set for ever.
let dir = tempfile::tempdir().unwrap();
worker::cancel_owned(dir.path(), 7, 1);
assert!(!worker::cancelled(dir.path(), 7), "nothing was queued for it");
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_panicking_recovery_write_is_an_error_and_the_writer_keeps_going() {
let err = worker::guarded(|| -> Result<()> { panic!("boom") }).unwrap_err();
assert!(err.to_string().contains("panicked") && err.to_string().contains("boom"), "{err}");
assert_eq!(worker::guarded(|| Ok(7)).unwrap(), 7, "the next write still runs");
}
#[test]
fn a_saved_document_is_not_written_in_the_background() {
// The autosave writes unsaved documents only.
let _turn = background();
let dir = tempfile::tempdir().unwrap();
let mut s = dirty_session();
s.recovery_dir = Some(dir.path().to_path_buf());
let saved = dir.path().join("saved.designcraft");
s.execute("file.saveAs", &json!({"path": saved.to_string_lossy()})).unwrap();
let queued = s.execute("file.recovery.save", &json!({"background": true})).unwrap();
assert_eq!(queued["queued"], 0, "{queued}");
assert_eq!(finished_writes(&mut s), 0);
assert!(list(dir.path()).is_empty());
}
#[test]
fn existing_recovery_directory_is_used() {
let root = tempfile::tempdir().unwrap();
@@ -440,6 +1168,11 @@ fn restart_recovery_child() {
}
}
/// A child process starts with a copy of every open file of this one until it runs its program, so
/// a lock file closed meanwhile stays locked: a test that closes a lock and expects it free does
/// not run while a child is started.
static SPAWN: std::sync::Mutex<()> = std::sync::Mutex::new(());
fn run_restart_case(mode: &str) {
let source = restart_fixture();
if mode == "max_uid" {
@@ -448,12 +1181,20 @@ fn run_restart_case(mode: &str) {
std::fs::rename(doc, max_doc).unwrap();
std::fs::rename(meta, max_meta).unwrap();
}
let output = std::process::Command::new(std::env::current_exe().unwrap())
.args(["--exact", "recovery::tests::restart_recovery_child", "--ignored", "--nocapture"])
.env("DESIGNCRAFT_TEST_RECOVERY_SOURCE", source.path())
.env("DESIGNCRAFT_TEST_RECOVERY_MODE", mode)
.output()
.unwrap();
// `spawn` returns once the child runs its program, and its copies of this process's files
// are closed by then.
let child = {
let _spawning = SPAWN.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
std::process::Command::new(std::env::current_exe().unwrap())
.args(["--exact", "recovery::tests::restart_recovery_child", "--ignored", "--nocapture"])
.env("DESIGNCRAFT_TEST_RECOVERY_SOURCE", source.path())
.env("DESIGNCRAFT_TEST_RECOVERY_MODE", mode)
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.spawn()
.unwrap()
};
let output = child.wait_with_output().unwrap();
assert!(output.status.success(), "fresh child failed: {}{}", String::from_utf8_lossy(&output.stdout), String::from_utf8_lossy(&output.stderr));
let child_stdout = String::from_utf8_lossy(&output.stdout);
assert!(child_stdout.contains("test result: ok. 1 passed; 0 failed;"), "the fresh-process helper did not run exactly once: {child_stdout}");
@@ -684,6 +1425,8 @@ fn documents_of_two_apps_that_ended_are_both_recovered() {
fn a_running_apps_recovery_data_is_left_alone() {
let root = tempfile::tempdir().unwrap();
let running = run_left(root.path(), "run-7-0", "still open", 1);
// No child starts while the lock is open, so closing it frees it (see `SPAWN`).
let _no_spawn = SPAWN.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
let lock = std::fs::File::open(running.join(LOCK)).unwrap();
lock.try_lock().unwrap();
let own = run_dir(root.path()).unwrap();
+20 -3
View File
@@ -91,6 +91,24 @@ fn save_with_large_entries_from(doc: &Document, preview: Option<&[u8]>, large_en
/// [`save_with_large_entries_from`], deflating only what a reader with `limits` inflates.
fn save_within(doc: &Document, preview: Option<&[u8]>, large_entry: usize, limits: Limits) -> Result<Vec<u8>, FormatError> {
let mut buf = Cursor::new(Vec::new());
write_with_large_entries_from(&mut buf, doc, preview, large_entry, limits)?;
Ok(buf.into_inner())
}
/// Write the package to `out` instead of returning it in memory: a document with gigabytes of
/// placed files needs no second copy in RAM (recovery snapshots, large saves).
pub fn write<W: Write + std::io::Seek>(out: &mut W, doc: &Document, preview: Option<&[u8]>) -> Result<(), FormatError> {
write_with_large_entries_from(out, doc, preview, LARGE_ENTRY, Limits::DEFAULT)
}
fn write_with_large_entries_from<W: Write + std::io::Seek>(
out: &mut W,
doc: &Document,
preview: Option<&[u8]>,
large_entry: usize,
limits: Limits,
) -> Result<(), FormatError> {
// JSON writes infinity and NaN as null, which no load accepts: the file would not open.
if let Some(id) = doc.non_finite_item() {
return Err(FormatError::Unsaveable(format!("object {} has a position or size that is not a finite number", id.0)));
@@ -99,9 +117,8 @@ fn save_within(doc: &Document, preview: Option<&[u8]>, large_entry: usize, limit
compact.compact_assets();
let doc = &compact;
let io = |e: zip::result::ZipError| FormatError::Io(e.to_string());
let mut buf = Cursor::new(Vec::new());
{
let mut z = zip::ZipWriter::new(&mut buf);
let mut z = zip::ZipWriter::new(out);
let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
let deflate = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
z.start_file("mimetype", stored).map_err(io)?;
@@ -140,7 +157,7 @@ fn save_within(doc: &Document, preview: Option<&[u8]>, large_entry: usize, limit
}
z.finish().map_err(io)?;
}
Ok(buf.into_inner())
Ok(())
}
/// The file name extension of a DesignCraft document.
+18
View File
@@ -651,6 +651,24 @@ fn saved_tab_lists_load_sanitized() {
assert_eq!(tabs.last().map(|t| t.position), Some(3960.0), "the first stops by position");
}
#[test]
fn writing_to_a_stream_makes_the_same_file_as_saving_in_memory() {
// A save that streams needs no copy of the archive in RAM; it must write the same package.
let mut d = Document::new(&NewDocument::default());
let a = png_asset(&mut d, b"streamed bytes");
place(&mut d, a, 0.0);
let png = b"\x89PNG streamed".to_vec();
let saved = save_with_preview(&d, Some(&png)).unwrap();
let mut out = Cursor::new(Vec::new());
write(&mut out, &d, Some(&png)).unwrap();
let streamed = out.into_inner();
assert_eq!(saved.len(), streamed.len());
assert_eq!(asset_entries(&streamed), 1);
let back = load(&streamed).unwrap();
assert_eq!(back.assets.len(), 1);
assert_eq!(read_preview(Cursor::new(&streamed)), Some(png));
}
#[test]
fn the_preview_is_read_back_without_the_document() {
let d = Document::new(&NewDocument::default());
+1
View File
@@ -44,6 +44,7 @@ zip = { workspace = true }
# Headless (offscreen wgpu) rendering of the whole window for UI screenshots: `examples/ui_shot.rs`.
egui_kittest = { workspace = true, features = ["wgpu", "snapshot"] }
designcraft-fonts = { workspace = true, features = ["testing"] }
designcraft-engine = { workspace = true, features = ["testing"] }
[build-dependencies]
serde_json = { workspace = true }
+1
View File
@@ -111,6 +111,7 @@ impl DesignApp {
shortcut_answers: Default::default(),
last_time: now,
last_recovery: now,
recovery_writing: false,
egui_ctx: None,
in_control: false,
object_clip_text: None,
+33 -7
View File
@@ -83,14 +83,28 @@ impl DesignApp {
/// uses the monotonic clock, so a wall-clock/NTP jump cannot postpone or advance it.
pub(super) fn ui_frame_end(&mut self, ctx: &egui::Context) {
let now = now_ms() / 1000.0;
// Crash recovery: unsaved documents are written to the recovery folder every 30 s.
// Crash recovery: unsaved documents are written to the recovery folder every 30 s, on a
// background thread — writing a catalogue with gigabytes of placed files took minutes, and
// on the interface thread the window stopped answering for all of it.
#[cfg(not(target_arch = "wasm32"))]
if self.session.recovery_dir.is_some() && now - self.last_recovery > (self.session.prefs.recovery_minutes * 60.0).max(5.0) {
self.last_recovery = now;
if self.session.documents().iter().any(|d| d.is_dirty())
&& let Err(e) = self.session.execute("file.recovery.save", &json!({}))
{
self.status(crate::i18n::tr(&self.ui.language, "Couldn't write recovery data: {error}").replace("{error}", &e.to_string()));
{
if self.session.recovery_dir.is_some() && now - self.last_recovery > (self.session.prefs.recovery_minutes * 60.0).max(5.0) {
self.last_recovery = now;
if self.session.documents().iter().any(|d| d.is_dirty()) {
match self.session.execute("file.recovery.save", &json!({"background": true})) {
Ok(v) if v["queued"].as_u64().unwrap_or(0) > 0 => self.recovery_writing = true,
Ok(_) => {}
Err(e) => self
.status(crate::i18n::tr(&self.ui.language, "Couldn't write recovery data: {error}").replace("{error}", &e.to_string())),
}
}
}
if self.recovery_writing {
self.poll_recovery();
// Keep the frames coming while the writer works; it has no interface to ask.
if self.recovery_writing {
ctx.request_repaint_after(std::time::Duration::from_millis(150));
}
}
}
let dt = now - self.last_time;
@@ -101,6 +115,18 @@ impl DesignApp {
self.issue_screenshots(ctx);
}
/// Take what the background recovery writer finished: its checkpoints, and what failed.
#[cfg(not(target_arch = "wasm32"))]
fn poll_recovery(&mut self) {
let Ok(v) = self.session.execute("file.recovery.progress", &json!({})) else { return };
self.recovery_writing = v["busy"].as_bool().unwrap_or(false);
let errors: Vec<String> = v["errors"].as_array().into_iter().flatten().filter_map(|e| e.as_str().map(str::to_string)).collect();
for e in errors {
let message = crate::i18n::tr(&self.ui.language, "Couldn't write recovery data: {error}").replace("{error}", &e);
self.status(message);
}
}
/// The document area: the start screen, or the document tabs over one or two canvas panes.
pub(crate) fn canvas_area(&mut self, ui: &mut egui::Ui, presenting: bool) {
let t = theme::Tokens::get(ui.ctx());
+205 -42
View File
@@ -556,6 +556,125 @@ mod color_theme_tests {
assert_eq!(opts(&app).columns, 1, "one undo step");
}
/// Opened with the caret on the last line of a frame, Text Frame Options keep acting on that
/// frame while a preview pushes the caret's line into the next frame of the thread.
#[test]
fn text_frame_options_keep_their_frame_while_the_preview_reflows_the_caret() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
app.run("file.new", json!({})).unwrap();
let text = (0..40).map(|i| format!("Line {i} of the threaded story.")).collect::<Vec<_>>().join(" ");
let a = app.run("frame.create", json!({"rect": [36, 36, 300, 120], "content": "text", "text": text})).unwrap();
let b = app.run("frame.create", json!({"rect": [36, 200, 300, 700], "content": "text", "text": "", "caret": false})).unwrap();
let (a, b, sid) =
(designcraft_doc::ItemId(a["id"].as_u64().unwrap()), designcraft_doc::ItemId(b["id"].as_u64().unwrap()), a["story"].as_u64().unwrap());
app.run("text.thread", json!({"from": a.0, "to": b.0})).unwrap();
let shown = |app: &DesignApp, f| {
let cs = designcraft_compose::compose_story(&app.session.doc().unwrap().doc, designcraft_doc::StoryId(sid), &Default::default());
cs.frame(f).unwrap().range.clone()
};
let caret = shown(&app, a).end - 1;
app.run("text.select", json!({"story": sid, "anchor": caret})).unwrap();
let inset = |app: &DesignApp, f| app.session.doc().unwrap().doc.item(f).unwrap().text_frame().unwrap().options.inset[0];
let mut d = Dialog::new("textFrameOptions", json!({}));
seed_text_frame_options(&app, &mut d);
d.fields.insert("inset".into(), json!("2p0"));
d.fields.insert("preview".into(), json!(true));
text_frame_preview(&mut app, &mut d);
assert!(shown(&app, b).contains(&caret), "the preview moved the caret's line into the next frame");
d.fields.insert("columns".into(), json!("2"));
text_frame_preview(&mut app, &mut d);
assert_eq!((inset(&app, a), inset(&app, b)), (24.0, 0.0), "the preview stays on the first frame");
app.ui.dialog = Some(d);
confirm(&mut app).unwrap();
assert_eq!((inset(&app, a), inset(&app, b)), (24.0, 0.0));
}
/// With the caret in the oval second frame of a thread whose first frame has uneven insets, the
/// dialog shows the one Inset of the oval and keeps the link on: both follow the frame it changes.
#[test]
fn text_frame_options_from_the_type_tool_show_the_inset_of_the_caret_frame() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
app.run("file.new", json!({})).unwrap();
let text = (0..40).map(|i| format!("Line {i} of the threaded story.")).collect::<Vec<_>>().join(" ");
let a = app.run("frame.create", json!({"rect": [36, 36, 300, 120], "content": "text", "text": text})).unwrap();
let b =
app.run("frame.create", json!({"rect": [36, 200, 300, 700], "shape": "ellipse", "content": "text", "text": "", "caret": false})).unwrap();
let (a, b, sid) =
(designcraft_doc::ItemId(a["id"].as_u64().unwrap()), designcraft_doc::ItemId(b["id"].as_u64().unwrap()), a["story"].as_u64().unwrap());
app.run("text.thread", json!({"from": a.0, "to": b.0})).unwrap();
app.run("object.textFrameOptions", json!({"ids": [a.0], "inset": [1, 2, 3, 4]})).unwrap();
let cs = designcraft_compose::compose_story(&app.session.doc().unwrap().doc, designcraft_doc::StoryId(sid), &Default::default());
let caret = cs.frame(b).unwrap().range.start + 2;
app.run("text.select", json!({"story": sid, "anchor": caret})).unwrap();
let mut d = Dialog::new("textFrameOptions", json!({}));
seed_text_frame_options(&app, &mut d);
assert_eq!(d.fields.get("_targets"), Some(&json!([b.0])));
assert!(d.b("_shaped"), "the oval shows one Inset");
assert!(d.b("insetLinked"), "the first frame's uneven sides do not turn the link off");
}
/// A preview shown in one document goes when OK is refused, or Cancel is chosen, after another
/// document became active.
#[test]
fn text_frame_options_preview_goes_from_its_document_after_another_becomes_active() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
let make = |app: &mut crate::DesignApp| {
app.run("file.new", json!({})).unwrap();
let r = app.run("frame.create", json!({"rect": [36, 36, 300, 300], "content": "text", "text": "Hello"})).unwrap();
app.run("text.select", json!({"story": r["story"], "anchor": 2})).unwrap();
designcraft_doc::ItemId(r["id"].as_u64().unwrap())
};
let a = make(&mut app);
let first = |app: &DesignApp| {
let st = &app.session.documents()[0];
(st.doc.item(a).unwrap().text_frame().unwrap().options.columns, st.interaction.is_some())
};
let preview = |app: &mut DesignApp| {
let mut d = Dialog::new("textFrameOptions", json!({}));
seed_text_frame_options(app, &mut d);
d.fields.insert("columns".into(), json!("3"));
d.fields.insert("preview".into(), json!(true));
text_frame_preview(app, &mut d);
assert_eq!(first(app), (3, true), "previewed in the first document");
d
};
let d = preview(&mut app);
make(&mut app);
app.ui.dialog = Some(d);
let err = confirm(&mut app).unwrap_err().to_string();
assert!(err.contains("no longer the active one"), "{err}");
assert_eq!(first(&app), (1, false), "OK refused: the first document is as it was");
app.ui.dialog = None;
app.session.set_active(0);
let d = preview(&mut app);
app.session.set_active(1);
app.ui.dialog = Some(d);
cancel(&mut app);
assert_eq!(first(&app), (1, false), "Cancel: the first document is as it was");
}
/// Undo puts back the document's id counter, so a frame made after Undo can take the id of a
/// frame the dialog stored; OK is refused instead of changing the new frame.
#[test]
fn text_frame_options_from_the_type_tool_are_refused_after_undo_reuses_the_frame_id() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
app.run("file.new", json!({})).unwrap();
let a = app.run("frame.create", json!({"rect": [36, 36, 300, 120], "content": "text", "text": "First"})).unwrap();
app.run("text.select", json!({"story": a["story"], "anchor": 1})).unwrap();
let mut d = Dialog::new("textFrameOptions", json!({}));
seed_text_frame_options(&app, &mut d);
d.fields.insert("columns".into(), json!("3"));
app.run("edit.undo", json!({})).unwrap();
let b = app.run("frame.create", json!({"rect": [36, 200, 300, 300], "content": "text", "text": "Second"})).unwrap();
assert_eq!(a["id"], b["id"], "the new frame takes the undone frame's id");
app.run("text.select", json!({"story": b["story"], "anchor": 1})).unwrap();
app.ui.dialog = Some(d);
let err = confirm(&mut app).unwrap_err().to_string();
assert!(err.contains("changed after the dialog opened"), "{err}");
let b = designcraft_doc::ItemId(b["id"].as_u64().unwrap());
assert_eq!(app.session.doc().unwrap().doc.item(b).unwrap().text_frame().unwrap().options.columns, 1, "the new frame is unchanged");
}
#[test]
fn toc_right_indent_separator_survives_the_dialog_and_update() {
let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
@@ -991,40 +1110,36 @@ fn pdf_export(app: &crate::DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {
}
}
/// The first frame Text Frame Options changes: the first selected item, the frame that shows the
/// caret, or the first frame holding selected text.
fn options_frame(app: &DesignApp) -> Option<designcraft_doc::ItemId> {
designcraft_engine::cmd::text_frame_options_frames(&app.session).first().copied()
}
/// The selected text frame's width (its own, before rotation).
fn selected_frame_width(app: &DesignApp) -> Option<f64> {
let st = app.session.active()?;
let fid = st.selection.items.first().copied().or_else(|| st.selection.text.and_then(|t| t.frame))?;
Some(st.doc.item(fid)?.inner_bounds().width())
Some(st.doc.item(options_frame(app)?)?.inner_bounds().width())
}
/// The options of the selected text frame (the first selected item, or the frame of the caret).
/// The options of the frame Text Frame Options shows.
fn selected_frame_options(app: &DesignApp) -> Option<designcraft_doc::TextFrameOptions> {
let st = app.session.active()?;
let fid = st.selection.items.first().copied().or_else(|| st.selection.text.and_then(|t| t.frame))?;
st.doc.item(fid)?.text_frame().map(|t| t.options.clone())
st.doc.item(options_frame(app)?)?.text_frame().map(|t| t.options.clone())
}
/// True when every text frame the dialog changes has the same inset on all four sides: the
/// selected items, else the caret's frame, else every frame of the caret's story.
/// selected items, else the frame that shows the caret or every frame holding selected text.
fn selected_frames_have_even_insets(app: &DesignApp) -> bool {
let Some(st) = app.session.active() else {
return true;
};
let mut ids = st.selection.items.clone();
if ids.is_empty()
&& let Some(t) = st.selection.text
{
ids = match t.frame {
Some(f) => vec![f],
None => st.doc.story(t.story).map(|s| s.frames.clone()).unwrap_or_default(),
};
}
let ids = designcraft_engine::cmd::text_frame_options_frames(&app.session);
ids.iter().filter_map(|id| st.doc.item(*id)?.text_frame()).all(|t| t.options.inset.iter().all(|v| (v - t.options.inset[0]).abs() < 1e-9))
}
/// Whether every selected text frame (the selected items, or the frame of the caret) has an
/// outline that is not its own axis-aligned rectangle: an oval, a polygon, rounded or other corner
/// Whether every text frame the dialog changes (the selected items, else the frame that shows the
/// caret or every frame holding selected text) has an outline that is not its own axis-aligned rectangle: an oval, a polygon, rounded or other corner
/// options. Its text keeps one inset from the outline, as compose sets it; type on a path doesn't.
/// A selection that mixes them with rectangular frames shows the four sides, so each frame keeps
/// the sides left as shown.
@@ -1038,11 +1153,8 @@ fn selected_frame_is_shaped(app: &DesignApp) -> bool {
let bp = if item.corners.is_none() { item.path.to_bezpath() } else { designcraft_geom::corners::apply(&item.path, &item.corners) };
Some(designcraft_compose::FrameOutline::new(&bp, 0.0).is_some())
};
if st.selection.items.is_empty() {
let Some(fid) = st.selection.text.and_then(|t| t.frame) else { return false };
return shaped(fid).unwrap_or(false);
}
st.selection.items.iter().all(|&fid| shaped(fid).unwrap_or(false))
let ids = designcraft_engine::cmd::text_frame_options_frames(&app.session);
!ids.is_empty() && ids.iter().all(|&fid| shaped(fid).unwrap_or(false))
}
/// Object › Text Frame Options shows the selected frame's options. `_shown` keeps what it showed,
@@ -1072,6 +1184,16 @@ fn seed_text_frame_options(app: &DesignApp, d: &mut Dialog) {
if let Some(w) = selected_frame_width(app) {
d.fields.insert("_frameWidth".into(), json!(w));
}
// Typing in a frame: the frames taken when the dialog opens, so a preview that reflows the
// text into another frame does not change which frames the options apply to.
if let Some(ids) = typing_frame_ids(app) {
d.fields.insert("_targets".into(), ids);
// The document state those frames are in: another document, or the document after
// Revert, can reuse their ids.
d.fields.insert("_targetsDoc".into(), json!(app.session.active().map(|doc| doc.identity_epoch)));
// Undo puts back the document's id counter, so a frame made after it can take a stored id.
d.fields.insert("_targetsRevision".into(), json!(app.session.active().map(base_revision)));
}
d.fields.insert("_shown".into(), shown);
}
@@ -1128,6 +1250,22 @@ pub(crate) fn text_frame_fields(
})
}
/// The document's revision without a preview on top: the one the open gesture began at.
fn base_revision(st: &designcraft_engine::DocState) -> u64 {
st.interaction.as_ref().map_or(st.revision, |it| it.revision)
}
/// With the Type tool and no frame selected: the frame that shows the caret, or every frame that
/// holds part of the selected text.
fn typing_frame_ids(app: &DesignApp) -> Option<Value> {
let st = app.session.active()?;
if !st.selection.items.is_empty() || st.selection.text.is_none() {
return None;
}
let ids: Vec<u64> = designcraft_engine::cmd::text_frame_options_frames(&app.session).iter().map(|f| f.0).collect();
Some(json!(ids))
}
/// A 0..1 tint as a percentage ("40", "12.5").
fn percent(t: f32) -> String {
let s = format!("{:.2}", f64::from(t) * 100.0);
@@ -1241,8 +1379,7 @@ fn text_frame_preview(app: &mut DesignApp, d: &mut Dialog) {
let shown = d.fields.get(PREVIEWED).cloned();
if !d.b("preview") {
if shown.is_some() {
app.session.cancel_interaction();
d.fields.remove(PREVIEWED);
end_text_frame_preview(app, d);
d.fields.remove("status");
}
return;
@@ -1252,8 +1389,7 @@ fn text_frame_preview(app: &mut DesignApp, d: &mut Dialog) {
Err(e) => {
// Values OK would refuse don't stay on the page: it goes back to how it was.
if shown.is_some() {
app.session.cancel_interaction();
d.fields.remove(PREVIEWED);
end_text_frame_preview(app, d);
}
d.fields.insert("status".into(), json!(e));
return;
@@ -1265,16 +1401,16 @@ fn text_frame_preview(app: &mut DesignApp, d: &mut Dialog) {
// Nothing edited (yet, or any more): the page as it was.
if params.as_object().is_some_and(|m| m.keys().all(|k| k == "ids")) {
if shown.is_some() {
app.session.cancel_interaction();
d.fields.remove(PREVIEWED);
end_text_frame_preview(app, d);
}
return;
}
if shown.is_none()
&& let Err(e) = app.session.begin_interaction("Text Frame Options")
{
d.fields.insert("status".into(), json!(e.to_string()));
return;
if shown.is_none() {
if let Err(e) = app.session.begin_interaction("Text Frame Options") {
d.fields.insert("status".into(), json!(e.to_string()));
return;
}
d.fields.insert(PREVIEW_DOC.into(), json!(app.session.active().map(|doc| doc.uid)));
}
match app.session.preview("object.textFrameOptions", params.clone()) {
Ok(()) => d.fields.remove("status"),
@@ -1283,6 +1419,15 @@ fn text_frame_preview(app: &mut DesignApp, d: &mut Dialog) {
d.fields.insert(PREVIEWED.into(), params);
}
/// The preview goes from the document it was shown in, also when another document is active now.
fn end_text_frame_preview(app: &mut DesignApp, d: &mut Dialog) {
d.fields.remove(PREVIEWED);
match d.fields.remove(PREVIEW_DOC).as_ref().and_then(Value::as_u64) {
Some(uid) => app.session.cancel_interaction_of(uid),
None => app.session.cancel_interaction(),
}
}
/// Text Frame Options › General, as InDesign's: Columns (kind, number and width, gutter and
/// maximum, Balance Columns), Inset Spacing (top and bottom, the link, left and right; one Inset
/// for a non-rectangular frame), Vertical Justification (align, paragraph spacing limit) and
@@ -1529,8 +1674,8 @@ fn text_frame_baseline_grid(d: &Dialog, bad: &dyn Fn(&str) -> String) -> Result<
fn confirm_text_frame_options(app: &mut DesignApp, d: &mut Dialog) -> Result<Value, String> {
seed_text_frame_options(app, d);
// The preview goes; the options are set once, as one undo step.
if d.fields.remove(PREVIEWED).is_some() {
app.session.cancel_interaction();
if d.fields.contains_key(PREVIEWED) {
end_text_frame_preview(app, d);
}
let p = text_frame_params(app, d)?;
if p.keys().all(|k| k == "ids") {
@@ -1632,16 +1777,28 @@ fn text_frame_params(app: &DesignApp, d: &Dialog) -> Result<Map<String, Value>,
json!(d.m("paragraphSpacingLimit").filter(|v| *v >= 0.0).ok_or_else(|| bad("the paragraph spacing limit is not a measure"))?),
);
}
// Typing in a frame: the options apply to that frame.
if let Some(st) = app.session.active()
&& st.selection.items.is_empty()
&& let Some(f) = st.selection.text.and_then(|t| t.frame)
{
p.insert("ids".into(), json!([f.0]));
if let Some(ids) = text_frame_targets(app, d).map_err(bad)? {
p.insert("ids".into(), ids);
}
Ok(p)
}
/// Typing in a frame: the frame that showed the caret, or every frame that held part of the
/// selected text, when the dialog opened. Those ids are refused once another document is active,
/// once Revert has replaced the document, or once the document has changed (Undo can give a new
/// frame a stored id).
fn text_frame_targets(app: &DesignApp, d: &Dialog) -> Result<Option<Value>, &'static str> {
let Some(ids) = d.fields.get("_targets").cloned() else { return Ok(typing_frame_ids(app)) };
let active = app.session.active().map(|doc| doc.identity_epoch);
if d.fields.get("_targetsDoc").and_then(Value::as_u64) != active {
return Err("the document the dialog opened on is no longer the active one");
}
if d.fields.get("_targetsRevision").and_then(Value::as_u64) != app.session.active().map(base_revision) {
return Err("the document changed after the dialog opened");
}
Ok(Some(ids))
}
/// File › Document Setup, filled from the document.
/// The active document's ruler unit (picas without a document).
fn doc_unit(app: &DesignApp) -> Unit {
@@ -4214,7 +4371,11 @@ pub fn cancel(app: &mut DesignApp) {
}
crate::new_document::end_preview(app);
if d.as_ref().is_some_and(|d| d.fields.contains_key(PREVIEWED)) {
app.session.cancel_interaction();
// Text Frame Options names the document its preview is in.
match d.as_ref().and_then(|d| d.fields.get(PREVIEW_DOC)).and_then(Value::as_u64) {
Some(uid) => app.session.cancel_interaction_of(uid),
None => app.session.cancel_interaction(),
}
}
app.cancel_pdf_import();
if let Some(d) = d
@@ -8944,6 +9105,8 @@ fn toc_dialog(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {
}
/// The params a previewing dialog shows on the page (its interaction is open while it is set).
const PREVIEWED: &str = "_previewed";
/// The uid of the document a Text Frame Options preview is shown in.
const PREVIEW_DOC: &str = "_previewDoc";
/// Edit › Step and Repeat, as in InDesign: Repeat (Count, or Rows and Columns with Create as a
/// grid), Offset (Vertical, Horizontal, in the document's ruler units) and Preview, which shows
+56 -3
View File
@@ -1512,6 +1512,59 @@ fn text_frame_options_set_columns_baseline_and_wrap_as_indesign_does() {
assert_eq!((opts(&app).columns_kind, opts(&app).column_width), (designcraft_doc::ColumnsKind::FixedNumber, 120.0));
}
/// The frames Text Frame Options took while typing belong to the document it opened on: when
/// another document becomes active before OK, OK changes nothing there.
#[test]
fn text_frame_options_from_the_type_tool_stay_with_their_document() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
let make = |app: &mut crate::DesignApp| {
app.run("file.new", json!({})).unwrap();
let r = app.run("frame.create", json!({"rect": [36, 36, 300, 300], "content": "text", "text": "Hello"})).unwrap();
let (id, story) = (r["id"].as_u64().unwrap(), r["story"].as_u64().unwrap());
app.run("text.select", json!({"story": story, "anchor": 2})).unwrap();
id
};
let a = make(&mut app);
let mut d = Dialog::new("textFrameOptions", json!({}));
seed_text_frame_options(&app, &mut d);
assert_eq!(d.fields.get("_targets"), Some(&json!([a])));
d.fields.insert("columns".into(), json!(3));
// A second document, with a caret in a frame that has the same id, becomes active.
let b = make(&mut app);
assert_eq!(a, b);
app.ui.dialog = Some(d);
let err = confirm(&mut app).unwrap_err().to_string();
assert!(err.contains("no longer the active one"), "{err}");
let columns = app.session.active().unwrap().doc.item(designcraft_doc::ItemId(b)).and_then(|i| i.text_frame().map(|t| t.options.columns));
assert_eq!(columns, Some(1), "the other document's frame is unchanged");
}
/// Revert replaces the document while Text Frame Options taken while typing stay open: OK is
/// refused, since the saved frame ids can name another frame in the reverted document.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn text_frame_options_from_the_type_tool_are_refused_after_revert() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
app.run("file.new", json!({})).unwrap();
let dir = tempfile::tempdir().unwrap();
app.run("file.saveAs", json!({"path": dir.path().join("revert.designcraft")})).unwrap();
let a = app.run("frame.create", json!({"rect": [36, 36, 300, 120], "content": "text", "text": "Unsaved"})).unwrap();
app.run("text.select", json!({"story": a["story"], "anchor": 1})).unwrap();
let mut d = Dialog::new("textFrameOptions", json!({}));
seed_text_frame_options(&app, &mut d);
d.fields.insert("columns".into(), json!(3));
app.run("file.revert", json!({})).unwrap();
let b = app.run("frame.create", json!({"rect": [36, 200, 300, 300], "content": "text", "text": "After"})).unwrap();
assert_eq!(a["id"], b["id"], "the reverted document gives a new frame the same id");
app.ui.dialog = Some(d);
let err = confirm(&mut app).unwrap_err().to_string();
assert!(err.contains("no longer the active one"), "{err}");
assert!(app.ui.dialog.is_some(), "the dialog stays open");
let b = designcraft_doc::ItemId(b["id"].as_u64().unwrap());
let columns = app.session.active().unwrap().doc.item(b).and_then(|i| i.text_frame().map(|t| t.options.columns));
assert_eq!(columns, Some(1), "the new frame is unchanged");
}
#[test]
fn baseline_grid_increment_error_explains_the_positive_measure_rule() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
@@ -1778,15 +1831,15 @@ fn text_frame_options_link_the_insets_only_when_every_selected_frame_has_even_si
assert!(!seeded(&app).b("insetLinked"));
app.run("text.select", json!({"story": other_even_story, "anchor": 0, "focus": 0})).unwrap();
assert!(seeded(&app).b("insetLinked"));
// A story threaded on into the uneven frame: a caret placed in the first frame changes only
// that frame, and a caret with no frame changes every frame of the story.
// A story threaded on into the uneven frame: a caret placed in the first frame, or a caret
// with no stored frame drawn in the first frame, changes only that frame.
let (first, story) = frame(&mut app, [300, 300, 500, 500], json!(6));
let (last, _) = frame(&mut app, [300, 520, 500, 700], json!([1, 2, 3, 4]));
app.run("text.thread", json!({"from": first.0, "to": last.0})).unwrap();
app.run("text.placeCaret", json!({"frame": first.0, "point": [310, 310]})).unwrap();
assert!(seeded(&app).b("insetLinked"));
app.run("text.select", json!({"story": story, "anchor": 0, "focus": 0})).unwrap();
assert!(!seeded(&app).b("insetLinked"));
assert!(seeded(&app).b("insetLinked"));
}
#[test]
+3
View File
@@ -255,6 +255,9 @@ pub struct DesignApp {
last_time: f64,
/// When recovery data was last written (seconds on the monotonic clock; see [`now_ms`]).
pub last_recovery: f64,
/// Recovery data is being written in the background: poll for it, and keep repainting.
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
pub(crate) recovery_writing: bool,
/// The egui context (set by the first UI pass): copied text goes to the system clipboard through it.
egui_ctx: Option<egui::Context>,
/// A control-channel request is being handled: commands it runs never read or write the
+27
View File
@@ -346,6 +346,33 @@ fn pdf_export_menu_item_opens_the_dialog_or_exports() {
assert!(app.ui.dialog.is_none());
}
/// With the Type tool in the second frame of a thread, Cmd+B opens Text Frame Options, and OK
/// changes the frame that shows the caret.
#[test]
fn text_frame_options_open_from_the_type_tool() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
app.run("file.new", json!({})).unwrap();
let text = (0..40).map(|i| format!("Line {i} of the threaded story.")).collect::<Vec<_>>().join(" ");
let a = app.run("frame.create", json!({"rect": [36, 36, 300, 120], "content": "text", "text": text})).unwrap();
let b = app.run("frame.create", json!({"rect": [36, 200, 300, 700], "content": "text", "text": "", "caret": false})).unwrap();
let (a, b, sid) = (a["id"].as_u64().unwrap(), b["id"].as_u64().unwrap(), a["story"].as_u64().unwrap());
app.run("text.thread", json!({"from": a, "to": b})).unwrap();
// The end of the story is in the second frame.
app.run("text.select", json!({"story": sid, "anchor": text.len()})).unwrap();
assert!(super::state::enabled(&app, "object.textFrameOptions"), "the menu item is enabled while typing");
let ctx = egui::Context::default();
press_keys(&mut app, &ctx, &[(egui::Key::B, egui::Modifiers::COMMAND)]);
assert_eq!(app.ui.dialog.as_ref().map(|d| d.id.as_str()), Some("textFrameOptions"), "Cmd+B opens the dialog while typing");
if let Some(d) = app.ui.dialog.as_mut() {
d.fields.insert("columns".into(), json!(3));
}
crate::dialogs::confirm(&mut app).unwrap();
let columns = |app: &crate::DesignApp, id: u64| {
app.session.active().unwrap().doc.item(designcraft_doc::ItemId(id)).and_then(|i| i.text_frame().map(|t| t.options.columns))
};
assert_eq!((columns(&app, a), columns(&app, b)), (Some(1), Some(3)));
}
#[test]
fn snap_preferences_are_a_command() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
@@ -1277,3 +1277,23 @@ fn transform_flips_and_rotates_from_properties() {
// The angle and scale fields are there.
assert!(h.query_by(|n| n.role() == egui::accesskit::Role::TextInput && n.value().as_deref() == Some("90°")).is_some());
}
/// With the Type tool, the Text Frame section shows the frame Text Frame Options change: the frame
/// the caret is drawn in, not the caret's stored frame.
#[test]
fn text_frame_section_shows_the_frame_that_shows_the_caret() {
use designcraft_doc::{ItemId, Selection, StoryId, TextSel};
let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
app.run("file.new", json!({})).unwrap();
let text = (0..40).map(|i| format!("Line {i} of the threaded story.")).collect::<Vec<_>>().join(" ");
let a = app.run("frame.create", json!({"rect": [36, 36, 300, 120], "content": "text", "text": text})).unwrap();
let b = app.run("frame.create", json!({"rect": [36, 200, 300, 700], "content": "text", "text": "", "caret": false})).unwrap();
let (a, b, sid) = (a["id"].as_u64().unwrap(), b["id"].as_u64().unwrap(), a["story"].as_u64().unwrap());
app.run("text.thread", json!({"from": a, "to": b})).unwrap();
app.run("object.textFrameOptions", json!({"ids": [b], "columns": 3})).unwrap();
// The end of the story is drawn in the second frame; the caret's stored frame is the first.
app.session.doc_mut().unwrap().selection =
Selection::text(TextSel { story: StoryId(sid), anchor: text.len(), focus: text.len(), frame: Some(ItemId(a)), cell: None });
let shown = super::text::text_frame_target(&app).map(|(id, o)| (id, o.columns));
assert_eq!(shown, Some((ItemId(b), 3)));
}
+12 -4
View File
@@ -516,13 +516,21 @@ pub(super) fn quick_actions_text(app: &mut DesignApp, ui: &mut Ui) {
}
}
/// Text Frame section: columns, gutter, [Options].
/// The text frame the Text Frame section shows, as Text Frame Options shows it: the first selected
/// frame, the frame that shows the caret, or the first frame holding selected text. Its id and its
/// options.
pub(super) fn text_frame_target(app: &DesignApp) -> Option<(designcraft_doc::ItemId, designcraft_doc::TextFrameOptions)> {
let st = app.session.active()?;
let fid = designcraft_engine::cmd::text_frame_options_frames(&app.session).first().copied()?;
Some((fid, st.doc.item(fid)?.text_frame()?.options.clone()))
}
/// Text Frame section: columns, gutter, [Options]. With the Type tool it changes the frame that
/// shows the caret, or every frame that holds part of the selected text.
pub(super) fn text_frame_section(app: &mut DesignApp, ui: &mut Ui) {
let t = Tokens::get(ui.ctx());
let u = units(app);
let Some(st) = app.session.active() else { return };
let fid = st.selection.items.first().copied().or_else(|| st.selection.text.and_then(|t| t.frame));
let Some(opts) = fid.and_then(|f| st.doc.item(f)).and_then(|i| i.text_frame()).map(|t| t.options.clone()) else { return };
let Some((_, opts)) = text_frame_target(app) else { return };
let b = block(ui, FIELD_H);
icons::paint(ui.painter(), sub(b, 0.0, 1.0, 19.0, 19.0), "text-columns", t.icon);
if let Some(v) = place(ui, sub(b, 22.0, 0.0, 54.0, FIELD_H), |ui| {
+41
View File
@@ -140,6 +140,47 @@ fn app_with_unsaved_document() -> DesignApp {
app
}
/// The recovery timer wrote the whole document on the interface thread: on a catalogue with
/// gigabytes of linked files the window stopped answering for minutes after every edit.
#[test]
fn the_recovery_timer_writes_off_the_interface_thread() {
let ctx = egui::Context::default();
let mut app = app_with_unsaved_document();
let dir = tempfile::tempdir().unwrap();
app.session.recovery_dir = Some(dir.path().to_path_buf());
app.last_recovery = -1.0e9;
let uid = app.session.documents()[0].uid;
let entry = dir.path().join(format!("{uid}.designcraft"));
// The writer stops at the start of the write until the test lets it go on, so a frame that
// waited for the write would never return.
let held = designcraft_engine::recovery::testing::hold_next_write(dir.path());
// egui discards a pass that needs another layout; the timer runs in the first pass it keeps.
for _ in 0..10 {
shot_frame(&mut app, &ctx, egui::vec2(1400.0, 900.0));
if app.last_recovery > 0.0 {
break;
}
}
assert!(app.last_recovery > 0.0, "the timer fired and restarted its interval");
assert!(!held.ran_here(), "the timer wrote the recovery data on the interface thread");
assert!(app.recovery_writing, "the timer queued the write");
held.wait_until_held();
// While the write is held, the interface keeps drawing frames and taking edits.
app.run("frame.create", json!({"rect": [20, 20, 80, 80]})).unwrap();
shot_frame(&mut app, &ctx, egui::vec2(1400.0, 900.0));
assert!(app.recovery_writing, "the write is still held");
assert!(!entry.exists(), "nothing is published while the write is held");
held.release();
designcraft_engine::recovery::testing::wait_until_idle();
shot_frame(&mut app, &ctx, egui::vec2(1400.0, 900.0));
assert!(!app.recovery_writing, "the frame after the write took its result");
assert!(entry.exists(), "the timer's background write published the document");
// The checkpoint is the document's: saving it removes the recovery entry.
let saved = dir.path().join("saved.designcraft");
app.run("file.saveAs", json!({"path": saved.to_string_lossy()})).unwrap();
assert!(!dir.path().join(format!("{uid}.designcraft")).exists());
}
/// File ▸ Close (and its shortcut) closed a document with unsaved changes without asking, and
/// closing discards the document's recovery data too.
#[test]
+5 -2
View File
@@ -1,6 +1,6 @@
# DesignCraft architecture
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (shared PDF writing) · **Target:** Adobe InDesign 2026
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-27 · **Change:** minor (recovery writes on a background thread, streamed to disk) · **Target:** Adobe InDesign 2026
How DesignCraft is built today. The design notes behind it are in `plan/architecture.md`
(local, gitignored); this file describes what the code on `main` does. Agents: AGENTS.md has the
@@ -58,7 +58,9 @@ panels, zoom, dialogs) are `UI_COMMANDS` in `crates/ui-egui/src/menus/ui_command
Tool gestures emit Begin/Preview/Commit commands so a drag is one undo step. Every journaled
command is replayable as a script. Escaped panics during a command or an import/export become an
error (`engine/src/guard.rs`), never a lost document; native recovery is written periodically
into each running app's locked folder. Orderly native shutdown finalizes complete, current quit
into each running app's locked folder, on a background thread and straight to disk, so an
autosave of a catalogue with gigabytes of placed files no longer stops the window answering.
Orderly native shutdown finalizes complete, current quit
approvals and writes the remaining documents' latest recovery state, including clean-document
cleanup after Undo. Unavailable or failed recovery is reported. The desktop opts into a pinned
winit 0.30 patch that cancels AppKit termination and queues ordinary window close requests,
@@ -119,6 +121,7 @@ builds (on manifest changes), packaging lint and the release workflow; `xtask ci
| Date | Change | Summary |
|---|---|---|
| 2026-10-27 | minor | Recovery writes off the interface thread, streamed to disk; a snapshot still being written when its document is saved, reverted or closed is cancelled |
| 2026-10-12 | minor | Documented cancelable Dock Quit through the native event-loop boundary |
| 2026-10-12 | minor | Documented orderly native exit recovery and the remaining cancelable Dock Quit gap |
| 2026-10-10 | major | Created from the code on main (92649ff) and `plan/architecture.md` |
+6 -2
View File
@@ -1,6 +1,6 @@
# Where DesignCraft falls short of InDesign
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-04 · **Change:** minor (gap 21 shrunk: pt-BR translates the whole interface; placed graphic layer-option preservation and explicit rendering warnings; gap 16 shrunk: File › File Info; gap 16: Convert Variable to Text; gap 28 added: placed-PDF font repair remains after visible unembedded font detection, #909; gap 26 shrunk: autoflow fills the following pages before it adds pages at the end; gap 6 shrunk: Type › Reload Fonts reads fonts installed, edited or removed while running (#328); gap 3: Package links are relative, #340; gap 27 closed: the loaded text cursor threads into a frame inside a group (#1075); .indd and .indt open through indd-utils; gap 0 shrunk: text threads by hand; threading gaps added; Optical kerning from outlines (#181); gap 6: macOS lists fonts that font services and managers activate; shared print spooler; image clipping paths from IDML; Tabs panel listed as present (#343); book chapter update safety; gap 16: Based on Parent leftovers; bounded control click/drag input; swatches on placed greyscale and bitmap images) · **Target:** Adobe InDesign 2026 (21.6)
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-04 · **Change:** minor (gap 20: automatic recovery moved off the interface thread; gap 21 shrunk: pt-BR translates the whole interface; placed graphic layer-option preservation and explicit rendering warnings; gap 16 shrunk: File › File Info; gap 16: Convert Variable to Text; gap 28 added: placed-PDF font repair remains after visible unembedded font detection, #909; gap 26 shrunk: autoflow fills the following pages before it adds pages at the end; gap 6 shrunk: Type › Reload Fonts reads fonts installed, edited or removed while running (#328); gap 3: Package links are relative, #340; gap 27 closed: the loaded text cursor threads into a frame inside a group (#1075); .indd and .indt open through indd-utils; gap 0 shrunk: text threads by hand; threading gaps added; Optical kerning from outlines (#181); gap 6: macOS lists fonts that font services and managers activate; shared print spooler; image clipping paths from IDML; Tabs panel listed as present (#343); book chapter update safety; gap 16: Based on Parent leftovers; bounded control click/drag input; swatches on placed greyscale and bitmap images) · **Target:** Adobe InDesign 2026 (21.6)
Every known shortfall against InDesign 2026, one entry each, ranked by how much it stops an
InDesign professional from doing real work. This is the work list: agents pick from the top.
@@ -240,7 +240,11 @@ Kind: **F** feature · **U** UI/UX · **T** typography · **FF** file format ·
against InDesign on long books and image-heavy catalogues.
- **Have:** compose 300k characters ~38 ms warm, damage-region repaint (< 1 ms while typing),
parallel story composition, and an edit composes only the paragraphs it can change in a plain
story (240 paragraphs: 3 composed for a typed character).
story (240 paragraphs: 3 composed for a typed character). Automatic recovery writes on a
background thread and streams to disk, so an autosave of that catalogue no longer blocks the
interface thread for 30-100 s (`file.recovery.save {background}`, `file.recovery.progress`). A
snapshot still being written when its document is saved, reverted or closed is cancelled before
it is published, so a crash cannot offer back a copy older than the saved file.
- **Estimate:** 40–80 h.
### 26. Autoflow flows into the primary text frame of the pages that follow (F)
+10
View File
@@ -231,6 +231,16 @@ execute {"command": "type.para", "params": {"attrs": {"hyphenate": fals
With a text selection, this formats the selected paragraphs; with selected text frames, it formats their whole stories.
`object.textFrameOptions` (columns, inset spacing, vertical justification and the rest of Text Frame Options) acts on
the selected frames or on the `ids` the call passes. With the Type tool and no frame selected, it acts on the frame that
shows the insertion point, or on every frame that holds part of the selected text, not on the other frames of the
thread. With the insertion point in a footnote or a table cell, it acts on the frame that shows the footnote or the
cell. An empty `ids`, or an `ids` that is not a list of object ids, is an error. Options a frame already has leave the document unchanged and add no undo step.
```text
execute {"command": "object.textFrameOptions", "params": {"verticalJustification": "center", "inset": 6}}
```
Use `execute` with `object.fit` to fit a selected graphic frame (or pass `ids`):
| `mode` | What it does |
+1
View File
@@ -352,6 +352,7 @@ It is evidence of breadth: each item exists. It is not a claim of InDesign-level
- Column rules (Text Frame Options › Column Rules, `object.textFrameOptions {columnRule, columnRuleWeight, columnRuleColor, columnRuleTint, columnRuleOffset, columnRuleTopInset, columnRuleBottomInset}`, reported by `document.inspect`): a bar centred in each gutter of a multi-column frame from the top line's ascent to the bottom line's descent, between the columns of right-to-left and vertical frames too, broken around paragraphs that span columns, with weight, colour, tint, horizontal offset and top/bottom insets; on screen, in PDF (tagged as an artifact) and in IDML (`ColumnRule…` attributes of `TextFramePreference`, also in object styles). The dialog shows the frame's options and changes only the fields edited. Rule stroke types and overprint aren't there yet.
- Auto-size (Text Frame Options › Auto-Size, `object.textFrameOptions {autoSize: off|heightOnly|widthOnly|heightAndWidth|heightAndWidthProportionally, autoSizeReference, useMinimumHeight, minimumHeight, useMinimumWidth, minimumWidth, noLineBreaks}`): the frame fits its text exactly after every edit (typing, pasting, style changes, option changes) in the same undo step (opening a file keeps the frame sizes it gives); it grows and shrinks around the reference point, which stays put in spread space for rotated frames too, never below the minimum height/width and never past 10,000 pt. Width Only and No Line Breaks set each paragraph on one line; Height and Width without No Line Breaks keeps the width; Keep Proportions scales both sides until the text fits. IDML keeps all the options (`AutoSizing…`, `…ForAutoSizing` attributes). Not covered: frames of a thread other than the last, vertical frames, type on a path, and multi-column balancing in Keep Proportions.
- Balance Columns (Text Frame Options › Balance Columns, `object.textFrameOptions {balanceColumns}`, IDML `VerticalBalanceColumns`): in the frame the story ends in, the columns after the last explicit column break fill to about the same depth (the last may be shorter by a line per column); keep options hold, spanning and split paragraphs keep their own balancing, vertical justification then applies to each column as usual, and vertical frames balance their bands. A frame the text runs on from, or that is overset, fills normally.
- Text Frame Options from the Type tool (Object › Text Frame Options…, Cmd+B, `object.textFrameOptions` without `ids`): with the insertion point in a frame, the options change the frame it is drawn in; with text selected, every frame that holds part of it. Options a frame already has add no undo step.
- Text Frame Options dialog, laid out as InDesign's (General, Column Rules, Baseline Options, Auto-Size; framed Columns, Inset Spacing and Vertical Justification groups with spinner fields; Fixed Number shows each column's width as the fields change). Preview shows the edits on the page until OK (one undo step) or Cancel. An invalid value (such as a gutter that isn't a measure) takes the preview off the page, so the frame shows as it was, and the dialog's status line gives the reason; OK refuses the value too. Preview stays checked and shows the edits again once the value is valid. Vertical Justification › Paragraph Spacing Limit (`object.textFrameOptions {paragraphSpacingLimit}`, IDML `VerticalThreshold`): with Justify, the extra space goes between paragraphs up to the limit, the rest between lines.
- Text Frame Options › Inset Spacing for a non-rectangular frame (an oval, a polygon, a frame with corner options; when every selected text frame is one, a mixed selection keeps the four sides): Top, Left, Bottom, Right and the link are dimmed, and one Inset field sets the distance kept between the text and the frame's outline (`object.textFrameOptions {inset: <number>}`, all four sides).
- Place a page of an IDML or DesignCraft document (`file.place {layoutPage}`): its objects, stories, styles and swatches as one group (INDD files are not readable).