GitCorner

Code

ossartcraftdesigncraft🌐
88f5a00e389b
use super::{Result, SpreadId, Value, bad, json};

/// A parent spread named by prefix, label (`A-Parent`) or index.
pub(super) fn parent_spread_index(d: &designcraft_doc::Document, v: &Value) -> Option<usize> {
    match v {
        Value::Number(n) => n.as_u64().and_then(|i| usize::try_from(i).ok()).filter(|i| *i < d.parents.len()),
        Value::String(s) => d.parents.iter().position(|p| p.parent.as_ref().is_some_and(|i| i.prefix == *s || i.label() == *s)),
        _ => None,
    }
}

/// A parent named by a command parameter: its id (a number), its full label (`"A-Parent"`), or
/// its prefix (`"A"`) when only one parent has it. `null` or `"[None]"` → `Some(None)` (no parent);
/// missing → `None` (the command's default). Unknown or ambiguous names are errors, so a typo never
/// clears a page's parent.
pub(super) fn parent_ref(cmd: &str, d: &designcraft_doc::Document, v: Option<&Value>) -> Result<Option<Option<SpreadId>>> {
    let Some(v) = v else { return Ok(None) };
    match v {
        Value::Null => Ok(Some(None)),
        Value::String(s) if s == "[None]" => Ok(Some(None)),
        Value::Number(n) => {
            let id = n.as_u64().ok_or_else(|| bad(cmd, format!("no parent with id {n}")))?;
            d.parents.iter().find(|p| p.id.0 == id).map(|p| Some(Some(p.id))).ok_or_else(|| bad(cmd, format!("no parent with id {id}")))
        }
        Value::String(s) => {
            let by = |f: &dyn Fn(&designcraft_doc::ParentInfo) -> bool| -> Vec<SpreadId> {
                d.parents.iter().filter(|p| p.parent.as_ref().is_some_and(f)).map(|p| p.id).collect()
            };
            let mut hits = by(&|i| i.label() == *s);
            if hits.is_empty() {
                hits = by(&|i| i.prefix == *s);
            }
            match hits.as_slice() {
                [id] => Ok(Some(Some(*id))),
                [] => Err(bad(cmd, format!("no parent named `{s}`"))),
                _ => Err(bad(cmd, format!("more than one parent is named `{s}`: give its id"))),
            }
        }
        _ => Err(bad(cmd, "`parent` is a parent id, a parent name or null")),
    }
}

/// Whether a parent other than index `except` is labelled `label` (`A-Parent`). Parents may share
/// a prefix, but a label names one parent.
pub(super) fn parent_label_taken(d: &designcraft_doc::Document, label: &str, except: Option<usize>) -> bool {
    d.parents.iter().enumerate().any(|(i, x)| Some(i) != except && x.parent.as_ref().is_some_and(|o| o.label() == label))
}

/// A parent prefix parameter: trimmed, 1–4 characters, no `-` (it separates prefix and name).
pub(super) fn parent_prefix_param(cmd: &str, p: &Value) -> Result<Option<String>> {
    let Some(v) = p.get("prefix") else { return Ok(None) };
    let s = v.as_str().ok_or_else(|| bad(cmd, "`prefix` is text"))?.trim();
    if s.is_empty() || s.chars().count() > 4 || s.contains('-') {
        return Err(bad(cmd, "a parent prefix has 1 to 4 characters and no `-`"));
    }
    Ok(Some(s.to_string()))
}

/// A parent name parameter: trimmed, not empty, at most 100 characters.
pub(super) fn parent_name_param(cmd: &str, p: &Value) -> Result<Option<String>> {
    let Some(v) = p.get("name") else { return Ok(None) };
    let s = v.as_str().ok_or_else(|| bad(cmd, "`name` is text"))?.trim();
    if s.is_empty() || s.chars().count() > 100 {
        return Err(bad(cmd, "a parent name has 1 to 100 characters"));
    }
    Ok(Some(s.to_string()))
}

/// Layout › Pages › Parent Options: prefix, name and Based on Parent. A base that would make a
/// cycle is refused.
pub(super) fn parent_options(s: &mut crate::Session, p: &Value) -> Result<Value> {
    const CMD: &str = "layout.parents.options";
    let prefix = parent_prefix_param(CMD, p)?;
    let name = parent_name_param(CMD, p)?;
    let d = &s.doc()?.doc;
    let Some(Some(id)) = parent_ref(CMD, d, p.get("parent"))? else { return Err(bad(CMD, "`parent` names the parent to change")) };
    let pi = d.parent_index(id).ok_or_else(|| bad(CMD, format!("no parent with id {}", id.0)))?;
    let info = d.parents.get(pi).and_then(|x| x.parent.clone()).ok_or_else(|| bad(CMD, "no such parent"))?;
    let base = match parent_ref(CMD, d, p.get("basedOn"))? {
        Some(b) => b,
        None => info.based_on,
    };
    if base == Some(id) {
        return Err(bad(CMD, format!("{} cannot be based on itself", info.label())));
    }
    let label = |d: &designcraft_doc::Document, i: usize| d.parents.get(i).and_then(|x| x.parent.as_ref()).map(|i| i.label());
    if let Some(b) = base
        && d.parent_base_cycles(pi, b)
    {
        let (name, b) = (info.label(), d.parent_index(b).and_then(|i| label(d, i)).unwrap_or_default());
        return Err(bad(CMD, format!("{name} cannot be based on {b}: that would make a cycle")));
    }
    let new = designcraft_doc::ParentInfo {
        prefix: prefix.unwrap_or_else(|| info.prefix.clone()),
        name: name.unwrap_or_else(|| info.name.clone()),
        based_on: base,
    };
    let out = json!({
        "parent": new.label(),
        "prefix": new.prefix,
        "name": new.name,
        "basedOn": base.and_then(|b| d.parent_index(b)).and_then(|i| label(d, i)),
    });
    if new == info {
        return Ok(out);
    }
    if parent_label_taken(d, &new.label(), Some(pi)) {
        return Err(bad(CMD, format!("a parent named {} exists", new.label())));
    }
    s.edit(|d, _| {
        let info = d.parents.get_mut(pi).map(std::sync::Arc::make_mut).and_then(|x| x.parent.as_mut()).ok_or_else(|| bad(CMD, "no such parent"))?;
        *info = new;
        Ok(out)
    })
}

pub(super) fn parent_page_target(d: &designcraft_doc::Document, p: &Value, cmd: &str) -> Result<(usize, usize)> {
    let parent = p.get("parent").and_then(Value::as_u64).map(SpreadId).ok_or_else(|| bad(cmd, "give a parent spread id"))?;
    let si = d.parent_index(parent).ok_or_else(|| bad(cmd, "no such parent"))?;
    let pi = p
        .get("page")
        .and_then(Value::as_u64)
        .and_then(|n| usize::try_from(n).ok())
        .filter(|i| *i < d.parents[si].pages.len())
        .ok_or_else(|| bad(cmd, "no such parent page"))?;
    Ok((si, pi))
}

pub(super) fn parent_page_size(s: &mut crate::Session, p: &Value) -> Result<Value> {
    const ID: &str = "layout.parentPageSize";
    let (si, pi) = parent_page_target(&s.doc()?.doc, p, ID)?;
    let size = |key| {
        p.get(key)
            .map(|v| {
                v.as_f64().filter(|v| v.is_finite() && *v > 0.0 && *v <= 15552.0).ok_or_else(|| bad(ID, "page size out of range (0 < size ≤ 216 in)"))
            })
            .transpose()
    };
    let (w, h) = (size("width")?, size("height")?);
    if w.is_none() && h.is_none() {
        return Err(bad(ID, "give width or height"));
    }
    let anchor = match p.get("anchor") {
        None => 0,
        Some(v) => v.as_u64().filter(|n| *n <= 8).ok_or_else(|| bad(ID, "anchor: 0–8"))? as usize,
    };
    s.edit(|d, _| {
        super::pages::resize_spread_page(d, designcraft_doc::SpreadRef::Parent(si), pi, w, h, anchor);
        d.sync_parent_margins();
        Ok(json!({"parent": d.parents[si].id.0, "page": pi}))
    })
}

#[cfg(test)]
mod parent_margin_tests {
    use designcraft_doc::{Document, Margins};
    use serde_json::json;

    use crate::Session;

    fn margins(d: &Document) -> Vec<(Margins, u32, bool)> {
        (0..d.page_count()).filter_map(|i| d.page(i)).map(|p| (p.margins, p.columns.count, p.local_margins)).collect()
    }

    #[test]
    fn document_setup_margins_let_pages_follow_their_parent_page_again() {
        let mut s = Session::new();
        s.execute("file.new", &json!({"pages": 3})).unwrap();
        s.execute("layout.marginsAndColumns", &json!({"pages": [1], "margins": 100})).unwrap();
        s.execute("layout.marginsAndColumns", &json!({"pages": [2], "margins": 100, "columns": 3})).unwrap();
        s.execute("layout.documentSetup", &json!({"margins": 20})).unwrap();
        let m = margins(&s.doc().unwrap().doc);
        let twenty = Margins::uniform(20.0);
        assert_eq!(m, vec![(twenty, 1, false), (twenty, 1, false), (twenty, 3, true)], "own columns stay local");
        s.execute("layout.marginsAndColumns", &json!({"parent": "A", "margins": 50})).unwrap();
        let m = margins(&s.doc().unwrap().doc);
        assert_eq!(m[1], (Margins::uniform(50.0), 1, false), "page 2 follows the parent page again");
        assert_eq!(m[2], (twenty, 3, true));
    }

    #[test]
    fn pages_follow_their_parent_pages_margins_unless_set_locally() {
        let mut s = Session::new();
        // Facing: [1] [2 3]; page 3 gets its own margins.
        s.execute("file.new", &json!({"pages": 3})).unwrap();
        s.execute("layout.marginsAndColumns", &json!({"pages": [2], "margins": 100})).unwrap();
        // A's left page: only the left document page follows.
        let left = json!({"top": 10, "bottom": 20, "inside": 30, "outside": 40});
        s.execute("layout.marginsAndColumns", &json!({"parent": "A", "pages": [0], "margins": left, "columns": 2})).unwrap();
        let l = Margins { top: 10.0, bottom: 20.0, inside: 30.0, outside: 40.0 };
        let m = margins(&s.doc().unwrap().doc);
        assert_eq!(m, vec![(Margins::uniform(36.0), 1, false), (l, 2, false), (Margins::uniform(100.0), 1, true)]);
        // A's right page: page 1 follows, page 3 keeps its own.
        s.execute("layout.marginsAndColumns", &json!({"parent": "A-Parent", "pages": [1], "margins": 50})).unwrap();
        let m = margins(&s.doc().unwrap().doc);
        assert_eq!(m, vec![(Margins::uniform(50.0), 1, false), (l, 2, false), (Margins::uniform(100.0), 1, true)]);
        // A page inserted after page 1 pushes page 2 to the right: it takes the right parent page's.
        s.execute("layout.pages.insert", &json!({"after": 0, "count": 1, "parent": "A"})).unwrap();
        let m = margins(&s.doc().unwrap().doc);
        assert_eq!(m[1], (l, 2, false), "the new left page");
        assert_eq!(m[2], (Margins::uniform(50.0), 1, false), "old page 2, now a right page");
        assert_eq!(m[3], (Margins::uniform(100.0), 1, true));
        assert!(s.execute("layout.marginsAndColumns", &json!({"parent": "Z", "margins": 10})).is_err());
    }

    /// Insert Pages before a page, or at the start of the document (`before: 0`), as InDesign's
    /// dialog offers; `after` and `before` together are refused without an undo step.
    #[test]
    fn pages_go_in_before_a_page_or_at_the_start() {
        let mut s = Session::new();
        // Facing: [1] [2 3].
        s.execute("file.new", &json!({"pages": 3})).unwrap();
        let b = s.execute("layout.parents.new", &json!({"prefix": "B"})).unwrap()["id"].as_u64().unwrap();
        let ids = |s: &Session| -> Vec<u64> {
            let d = &s.doc().unwrap().doc;
            (0..d.page_count()).map(|i| d.page(i).unwrap().id.0).collect()
        };
        let parent = |s: &Session, i: usize| s.doc().unwrap().doc.page(i).unwrap().parent.map(|p| p.0);
        let old = ids(&s);
        s.execute("layout.pages.insert", &json!({"before": 0, "parent": "B"})).unwrap();
        let now = ids(&s);
        assert_eq!(now.len(), 4);
        assert_eq!(now[1..], old[..], "the old pages follow the new first page");
        assert_eq!(parent(&s, 0), Some(b));
        // Before page 4 (index 3, the old page 3): two pages without a parent.
        s.execute("layout.pages.insert", &json!({"before": 3, "count": 2, "parent": null})).unwrap();
        let then = ids(&s);
        assert_eq!(then.len(), 6);
        assert_eq!(then[..3], now[..3]);
        assert_eq!(then[5], old[2]);
        assert_eq!((parent(&s, 3), parent(&s, 4)), (None, None));
        // Refused without a change or an undo step: both placements, even one of them null, and a
        // placement that isn't a page index.
        let undo = s.doc().unwrap().history.undo.len();
        for bad in [
            json!({"after": 0, "before": 1}),
            json!({"after": 0, "before": null}),
            json!({"after": null, "before": 1}),
            json!({"before": -1}),
            json!({"before": "0"}),
            json!({"before": null}),
            json!({"after": 1.5}),
            json!({"before": 6}),
            json!({"before": 99}),
        ] {
            assert!(s.execute("layout.pages.insert", &bad).is_err(), "{bad}");
            assert_eq!(s.doc().unwrap().history.undo.len(), undo, "{bad}");
            assert_eq!(ids(&s), then, "{bad}");
        }
    }

    #[test]
    fn applying_a_parent_gives_its_margins_and_local_margins_stay_local() {
        let mut s = Session::new();
        // Facing: [1] [2 3].
        s.execute("file.new", &json!({"pages": 3})).unwrap();
        s.execute("layout.parents.new", &json!({"prefix": "B"})).unwrap();
        s.execute("layout.marginsAndColumns", &json!({"parent": "B", "margins": 70, "columns": 3})).unwrap();
        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "B"})).unwrap();
        let m = margins(&s.doc().unwrap().doc);
        assert_eq!(m[1], (Margins::uniform(70.0), 3, false), "the page takes B's margins");
        // Page 3 is given margins equal to A's: they are its own all the same.
        s.execute("layout.marginsAndColumns", &json!({"pages": [2], "margins": 36})).unwrap();
        s.execute("layout.marginsAndColumns", &json!({"parent": "A", "margins": 20})).unwrap();
        let m = margins(&s.doc().unwrap().doc);
        assert_eq!(m[0], (Margins::uniform(20.0), 1, false));
        assert_eq!(m[1], (Margins::uniform(70.0), 3, false), "B's page is not A's");
        assert_eq!(m[2], (Margins::uniform(36.0), 1, true));
        // Back to A: page 2 follows A again.
        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "A"})).unwrap();
        assert_eq!(margins(&s.doc().unwrap().doc)[1], (Margins::uniform(20.0), 1, false));
    }

    #[test]
    fn parent_guides_show_on_pages_but_stay_on_the_parent() {
        let mut s = Session::new();
        s.execute("file.new", &json!({"pages": 2})).unwrap();
        // A vertical guide 100 pt into A's right page (x = 612 in the parent spread).
        s.execute("guide.add", &json!({"spread": {"kind": "parent", "index": 0}, "page": 1, "orientation": "vertical", "position": 712})).unwrap();
        let d = &s.doc().unwrap().doc;
        let right = d.page(0).unwrap();
        let shown: Vec<f64> = d.parent_guides(right).map(|g| g.position).collect();
        assert_eq!(shown, vec![100.0], "moved to the document page's place");
        assert_eq!(d.parent_guides(d.page(1).unwrap()).count(), 0, "the left page shows A's left page's guides");
        // Not the document page's own: not listed, moved or deleted from there.
        assert_eq!(s.execute("guide.list", &json!({"spread": 0})).unwrap(), json!([]));
        assert!(s.execute("guide.move", &json!({"spread": 0, "page": 0, "index": 0, "position": 50})).is_err());
        assert!(s.execute("guide.delete", &json!({"spread": 0, "page": 0, "index": 0})).is_err());
    }
}

#[cfg(test)]
mod parent_tests {
    use serde_json::json;

    fn parent_of(s: &crate::Session, page: usize) -> Option<u64> {
        s.doc().unwrap().doc.page(page).unwrap().parent.map(|p| p.0)
    }

    #[test]
    fn parents_with_one_prefix_stay_distinct() {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({"pages": 2})).unwrap();
        let a = s.execute("layout.parents.new", &json!({"prefix": "IMG", "name": "Parent"})).unwrap()["id"].as_u64().unwrap();
        let b = s.execute("layout.parents.new", &json!({"prefix": "IMG", "name": "Half"})).unwrap()["id"].as_u64().unwrap();
        s.execute("layout.pages.applyParent", &json!({"pages": [0], "parent": b})).unwrap();
        assert_eq!(parent_of(&s, 0), Some(b));
        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "IMG-Half"})).unwrap();
        assert_eq!(parent_of(&s, 1), Some(b));
        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "IMG-Parent"})).unwrap();
        assert_eq!(parent_of(&s, 1), Some(a));
        // A prefix two parents share, or a name no parent has, is an error and changes nothing.
        assert!(s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "IMG"})).is_err());
        assert!(s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "Nope"})).is_err());
        assert!(s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": 999_999})).is_err());
        assert_eq!(parent_of(&s, 1), Some(a));
        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "[None]"})).unwrap();
        assert_eq!(parent_of(&s, 1), None);
    }

    #[test]
    fn new_parents_take_the_next_letters_and_options_rename_them() {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({"pages": 2})).unwrap();
        let b = s.execute("layout.parents.new", &json!({})).unwrap();
        assert_eq!(b["prefix"], "B");
        let c = s.execute("layout.parents.new", &json!({"basedOn": "A"})).unwrap();
        assert_eq!(c["prefix"], "C");
        let (b, c) = (b["id"].as_u64().unwrap(), c["id"].as_u64().unwrap());
        let info = |s: &crate::Session, id: u64| {
            let d = &s.doc().unwrap().doc;
            d.parents.iter().find(|p| p.id.0 == id).and_then(|p| p.parent.clone()).unwrap()
        };
        assert!(info(&s, c).based_on.is_some());
        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": b})).unwrap();
        let r = s.execute("layout.parents.options", &json!({"parent": "B", "prefix": " Z ", "name": "Cover"})).unwrap();
        assert_eq!(r["parent"], "Z-Cover");
        assert_eq!(info(&s, b).label(), "Z-Cover");
        // The page keeps its parent, now called Z-Cover; Based On is untouched when not given.
        assert_eq!(parent_of(&s, 1), Some(b));
        assert!(info(&s, c).based_on.is_some());
        s.execute("layout.parents.options", &json!({"parent": "C", "name": "Back"})).unwrap();
        assert_eq!(info(&s, c).label(), "C-Back");
        assert!(info(&s, c).based_on.is_some(), "a rename keeps the base");
        // Bad prefixes and names change nothing and add no history.
        let undo = s.doc().unwrap().history.undo.len();
        for bad in [json!({"prefix": ""}), json!({"prefix": "ABCDE"}), json!({"prefix": "A-B"}), json!({"name": "  "}), json!({"prefix": 3})] {
            let mut p = bad.clone();
            p["parent"] = json!(b);
            assert!(s.execute("layout.parents.options", &p).is_err(), "{bad}");
            assert!(s.execute("layout.parents.new", &bad).is_err(), "{bad}");
        }
        assert!(s.execute("layout.parents.options", &json!({"parent": "C", "basedOn": "C-Back"})).is_err());
        // A label names one parent: taking another parent's label is refused, a prefix may be shared.
        assert!(s.execute("layout.parents.options", &json!({"parent": "C-Back", "prefix": "Z", "name": "Cover"})).is_err());
        assert!(s.execute("layout.parents.new", &json!({"prefix": "Z", "name": "Cover"})).is_err());
        assert!(s.execute("layout.parents.options", &json!({"parent": "C-Back", "prefix": "Z"})).is_ok());
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(s.doc().unwrap().history.undo.len(), undo);
        assert_eq!(info(&s, b).label(), "Z-Cover");
        // Four characters, including non-Latin ones, are fine.
        s.execute("layout.parents.options", &json!({"parent": b, "prefix": "表紙ページ".chars().take(4).collect::<String>()})).unwrap();
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(info(&s, b).label(), "Z-Cover");
    }

    #[test]
    fn duplicate_parent_copies_pages_and_items_with_a_new_prefix() {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({"pages": 2})).unwrap();
        let a = json!({"kind": "parent", "index": 0});
        s.execute("frame.create", &json!({"spread": a, "rect": [40, 40, 200, 100], "content": "text"})).unwrap();
        s.execute("frame.create", &json!({"spread": a, "rect": [60, 200, 160, 300]})).unwrap();
        let n = s.doc().unwrap().doc.parents.len();
        let r = s.execute("layout.parents.duplicate", &json!({"parent": "A-Parent"})).unwrap();
        assert_eq!(r["prefix"], "B");
        let d = &s.doc().unwrap().doc;
        assert_eq!(d.parents.len(), n + 1);
        let (src, copy) = (&d.parents[0], &d.parents[n]);
        assert_eq!(copy.id.0, r["id"].as_u64().unwrap());
        assert_eq!(copy.parent.as_ref().unwrap().label(), "B-Parent");
        assert_eq!(copy.pages.len(), src.pages.len());
        assert_eq!(copy.items.len(), 2);
        assert!(copy.pages.iter().all(|p| src.pages.iter().all(|q| q.id != p.id)));
        assert!(copy.items.iter().all(|i| src.items.iter().all(|j| j.id != i.id)));
        // The copied text frame has its own story.
        let story = |it: &designcraft_doc::Item| it.text_frame().map(|t| t.story);
        let (s0, s1) = (src.items.iter().find_map(|i| story(i)), copy.items.iter().find_map(|i| story(i)));
        assert!(s0.is_some() && s1.is_some() && s0 != s1);
        assert!(s.execute("layout.parents.duplicate", &json!({"parent": "Nope"})).is_err());
        assert!(s.execute("layout.parents.duplicate", &json!({})).is_err());
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(s.doc().unwrap().doc.parents.len(), n);
    }

    #[test]
    fn edit_parents_shows_the_named_parent() {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({})).unwrap();
        let ids: Vec<u64> =
            ["B", "C", "D"].iter().map(|p| s.execute("layout.parents.new", &json!({"prefix": p})).unwrap()["id"].as_u64().unwrap()).collect();
        s.ui_requests.clear();
        let r = s.execute("layout.parents.edit", &json!({"parent": ids[2]})).unwrap();
        assert_eq!(r, json!({"on": true, "parent": ids[2]}));
        assert!(s.doc().unwrap().editing_parents);
        let n = s.doc().unwrap().doc.parent_index(designcraft_doc::SpreadId(ids[2])).unwrap();
        let shown: Vec<_> = s
            .ui_requests
            .iter()
            .filter_map(|r| match r {
                crate::UiRequest::View { params } => params.get("showSpread").cloned(),
                _ => None,
            })
            .collect();
        assert_eq!(shown, vec![json!({"kind": "parent", "index": n})]);
        let r = s.execute("layout.parents.edit", &json!({"on": true, "parent": "C-Parent"})).unwrap();
        assert_eq!(r["parent"], ids[1]);
        assert!(s.execute("layout.parents.edit", &json!({"parent": "Z-Parent"})).is_err());
        let r = s.execute("layout.parents.edit", &json!({"on": false})).unwrap();
        assert_eq!(r, json!({"on": false, "parent": null}));
        assert!(!s.doc().unwrap().editing_parents);
    }

    /// A new parent takes the first page's columns, dragged column guides included: the right
    /// parent page as the first (right) page has them, the left one mirrored across the spine.
    /// `document.inspect` reports where those columns are.
    #[test]
    fn a_new_parent_keeps_dragged_columns() {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({"pages": 1})).unwrap();
        let dragged = designcraft_doc::Columns { count: 2, gutter: 12.0, positions: Some(vec![0.0, 100.0, 130.0, 540.0]) };
        // There is no command for dragging a column guide yet, so set what an import would leave.
        s.edit(|d, _| {
            let pg = &mut std::sync::Arc::make_mut(&mut d.spreads[0]).pages[0];
            (pg.columns, pg.local_margins) = (dragged.clone(), true);
            Ok(())
        })
        .unwrap();
        let id = s.execute("layout.parents.new", &json!({"prefix": "B"})).unwrap()["id"].as_u64().unwrap();
        let d = &s.doc().unwrap().doc;
        let parent = d.parents.iter().find(|p| p.id.0 == id).unwrap();
        assert_eq!(parent.pages.len(), 2);
        let side = |s: designcraft_doc::PageSide| parent.pages.iter().find(|p| p.side == s).unwrap();
        let (left, right) = (side(designcraft_doc::PageSide::Left), side(designcraft_doc::PageSide::Right));
        assert_eq!(right.columns, dragged);
        assert_eq!(right.column_rects().iter().map(|r| r.width()).collect::<Vec<_>>(), vec![100.0, 410.0]);
        assert_eq!(left.columns.positions, Some(vec![0.0, 410.0, 440.0, 540.0]));
        assert_eq!(left.column_rects().iter().map(|r| r.width()).collect::<Vec<_>>(), vec![410.0, 100.0]);

        let inspect = s.execute("document.inspect", &json!({})).unwrap();
        let page = &inspect["spreads"][0]["pages"][0];
        assert_eq!((page["columns"].clone(), page["customColumns"].clone()), (json!(2), json!(true)), "{page}");
        assert_eq!(page["columnRects"][0], json!([36.0, 36.0, 136.0, 756.0]), "{page}");
    }

    fn columns_of(s: &crate::Session, abs: usize) -> (Option<Vec<f64>>, bool) {
        let pg = s.doc().unwrap().doc.page(abs).unwrap().clone();
        (pg.columns.positions, pg.local_margins)
    }

    /// Three columns across a 540 pt margin box (36 pt margins), column guides unlocked.
    fn three_columns(pages: u64) -> crate::Session {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({"pages": pages})).unwrap();
        s.execute("layout.marginsAndColumns", &json!({"parent": "A", "columns": 3, "gutter": 12})).unwrap();
        s.execute("view.lockColumnGuides", &json!({"on": false})).unwrap();
        s
    }

    /// Dragging a column guide moves its gutter's two guides together, stops at the neighbouring
    /// gutter and the margin, makes a following page's columns its own, and undoes in one step.
    #[test]
    fn move_column_guide_moves_the_gutter_pair_within_its_neighbours() {
        let mut s = three_columns(1);
        assert_eq!(columns_of(&s, 0), (None, false), "the page follows A");
        let mv =
            |s: &mut crate::Session, gutter: u64, x: f64| s.execute("layout.moveColumnGuide", &json!({"page": 0, "gutter": gutter, "position": x}));
        let r = mv(&mut s, 0, 236.0).unwrap();
        assert_eq!(r, json!({"positions": [0.0, 200.0, 212.0, 356.0, 368.0, 540.0], "left": 236.0}));
        assert_eq!(columns_of(&s, 0), (Some(vec![0.0, 200.0, 212.0, 356.0, 368.0, 540.0]), true));
        let inspect = s.execute("document.inspect", &json!({})).unwrap();
        assert_eq!(inspect["spreads"][0]["pages"][0]["columnRects"][0], json!([36.0, 36.0, 236.0, 756.0]));
        // Past the next gutter: it stops there, and the middle column has no width.
        assert_eq!(mv(&mut s, 0, 1000.0).unwrap()["left"], json!(36.0 + 344.0));
        // Past the right margin: the last gutter stops 12 pt (its width) inside it.
        assert_eq!(mv(&mut s, 1, 1e12).unwrap()["positions"], json!([0.0, 344.0, 356.0, 528.0, 540.0, 540.0]));
        // Past the left margin.
        assert_eq!(mv(&mut s, 0, -1e12).unwrap()["positions"], json!([0.0, 0.0, 12.0, 528.0, 540.0, 540.0]));
        for _ in 0..3 {
            s.execute("edit.undo", &json!({})).unwrap();
        }
        assert_eq!(columns_of(&s, 0), (Some(vec![0.0, 200.0, 212.0, 356.0, 368.0, 540.0]), true));
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(columns_of(&s, 0), (None, false), "one undo step per drag");
    }

    /// On a parent page the drag changes the parent, and the document pages that follow it get
    /// the new columns; a page with columns of its own keeps them.
    #[test]
    fn move_column_guide_on_a_parent_reaches_the_pages_that_follow_it() {
        let mut s = three_columns(3);
        // Page 1, the left page of spread 1, gets columns of its own.
        let x = s.doc().unwrap().doc.spreads[1].pages[0].margin_rect().x0 + 300.0;
        s.execute("layout.moveColumnGuide", &json!({"spread": 1, "page": 0, "gutter": 1, "position": x})).unwrap();
        let own = columns_of(&s, 1);
        assert!(own.1 && own.0.is_some());
        let d = &s.doc().unwrap().doc;
        // A's right page: the one page 0 (a right page) and page 2 follow.
        let x0 = d.parents[0].pages[1].margin_rect().x0;
        s.execute("layout.moveColumnGuide", &json!({"parent": "A", "page": 1, "gutter": 0, "position": x0 + 100.0})).unwrap();
        let moved = vec![0.0, 100.0, 112.0, 356.0, 368.0, 540.0];
        assert_eq!(s.doc().unwrap().doc.parents[0].pages[1].columns.positions, Some(moved.clone()));
        assert_eq!(columns_of(&s, 0), (Some(moved.clone()), false));
        assert_eq!(columns_of(&s, 2), (Some(moved), false));
        assert_eq!(columns_of(&s, 1), own, "page 1's columns are its own");
        // The same parent page by spread reference.
        let spread = json!({"kind": "parent", "index": 0});
        s.execute("layout.moveColumnGuide", &json!({"spread": spread, "page": 1, "gutter": 0, "position": x0 + 50.0})).unwrap();
        assert_eq!(columns_of(&s, 0).0.unwrap()[1], 50.0);
    }

    /// A drag's preview in one document is put back there when another document became active.
    #[test]
    fn a_column_guide_preview_is_cancelled_in_its_own_document() {
        let mut s = three_columns(1);
        let uid = s.doc().unwrap().uid;
        s.begin_interaction("Move Column Guide").unwrap();
        s.preview("layout.moveColumnGuide", json!({"page": 0, "gutter": 0, "position": 236})).unwrap();
        s.execute("file.new", &json!({})).unwrap();
        s.cancel_interaction_of(uid);
        s.set_active(0);
        assert!(s.doc().unwrap().interaction.is_none());
        assert_eq!(columns_of(&s, 0), (None, false));
    }

    #[test]
    fn move_column_guide_refuses_while_locked_and_hostile_params() {
        let mut s = three_columns(1);
        s.execute("view.lockColumnGuides", &json!({"on": true})).unwrap();
        assert!(s.execute("layout.moveColumnGuide", &json!({"page": 0, "gutter": 0, "position": 200})).is_err());
        assert_eq!(columns_of(&s, 0), (None, false));
        s.execute("view.lockColumnGuides", &json!({"on": false})).unwrap();
        for p in [
            json!({"page": 0, "gutter": 0}),
            json!({"page": 0, "gutter": 0, "position": f64::NAN}),
            json!({"page": 0, "gutter": 0, "position": "200"}),
            json!({"page": 0, "gutter": 2, "position": 200}),
            json!({"page": 0, "gutter": u64::MAX, "position": 200}),
            json!({"page": 0, "gutter": -1, "position": 200}),
            json!({"page": 0, "gutter": 0.5, "position": 200}),
            json!({"page": 9, "gutter": 0, "position": 200}),
            json!({"page": u64::MAX, "gutter": 0, "position": 200}),
            json!({"gutter": 0, "position": 200}),
            json!({"spread": 99, "page": 0, "gutter": 0, "position": 200}),
            json!({"parent": "Z", "page": 0, "gutter": 0, "position": 200}),
            json!({"page": 0, "gutter": 0, "position": f64::MAX}),
        ] {
            let r = s.execute("layout.moveColumnGuide", &p);
            // A huge but finite position is clamped to the margin; everything else is refused.
            assert!(r.is_err() || p["position"] == json!(f64::MAX), "{p}: {r:?}");
        }
    }
}

#[cfg(test)]
mod parent_base_tests {
    use serde_json::{Value, json};

    fn rect(s: &mut crate::Session, spread: Value, r: [f64; 4], swatch: &str) -> u64 {
        let id = s.execute("frame.create", &json!({"spread": spread, "rect": r, "content": "unassigned"})).unwrap()["id"].as_u64().unwrap();
        s.execute("object.fill", &json!({"ids": [id], "swatch": swatch})).unwrap();
        id
    }

    fn page(s: &crate::Session, abs: usize) -> designcraft_render::Rendered {
        let mut rr = designcraft_render::Renderer::new();
        rr.threads = 0;
        rr.render_page(&s.doc().unwrap().doc, &s.cache, abs, 1.0, false, &Default::default()).unwrap()
    }

    /// Parent A (black), parent B based on A (cyan, half over A's square), and a page item (paper)
    /// over B's: the page draws A, then B, then its own items.
    #[test]
    fn based_on_parent_draws_base_items_under_parent_items() {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({"width": 400, "height": 400, "pages": 2, "facingPages": false, "margins": 0})).unwrap();
        s.execute("layout.parents.new", &json!({"prefix": "B", "name": "Opening"})).unwrap();
        rect(&mut s, json!({"kind": "parent", "index": 0}), [0.0, 0.0, 200.0, 200.0], "[Black]");
        rect(&mut s, json!({"kind": "parent", "index": 1}), [100.0, 0.0, 300.0, 200.0], "C=100 M=0 Y=0 K=0");
        rect(&mut s, json!(1), [150.0, 0.0, 190.0, 40.0], "[Paper]");
        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "B"})).unwrap();
        let black = |p: [u8; 4]| p[0] < 80 && p[1] < 80 && p[2] < 80;
        let cyan = |p: [u8; 4]| p[0] < 80 && p[1] > 120 && p[2] > 180;
        let paper = |p: [u8; 4]| p[0] > 240 && p[1] > 240 && p[2] > 240;
        assert!(paper(page(&s, 1).pixel(50, 100)), "B alone does not show A's items");

        let r = s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": "A"})).unwrap();
        assert_eq!(r, json!({"parent": "B-Opening", "prefix": "B", "name": "Opening", "basedOn": "A-Parent"}));
        let img = page(&s, 1);
        assert!(black(img.pixel(50, 100)), "A's item: {:?}", img.pixel(50, 100));
        assert!(cyan(img.pixel(150, 150)), "B's item over A's: {:?}", img.pixel(150, 150));
        assert!(paper(img.pixel(170, 20)), "the page's item over B's: {:?}", img.pixel(170, 20));
        assert!(black(page(&s, 0).pixel(50, 100)) && !cyan(page(&s, 0).pixel(250, 100)), "page 1 uses A only");
        // Parent B itself shows A's items under its own.
        let mut rr = designcraft_render::Renderer::new();
        rr.threads = 0;
        let placed = [designcraft_render::Placed { spread: designcraft_doc::SpreadRef::Parent(1), xf: designcraft_geom::Affine::IDENTITY }];
        let opts = designcraft_render::RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
        let img = rr.render(&s.doc().unwrap().doc, &s.cache, &placed, (400, 400), designcraft_geom::Affine::IDENTITY, &opts);
        assert!(black(img.pixel(50, 100)) && cyan(img.pixel(150, 150)), "{:?} {:?}", img.pixel(50, 100), img.pixel(150, 150));
        let inspect = s.execute("document.inspect", &json!({})).unwrap();
        assert_eq!(inspect["parents"][1]["basedOn"], "A-Parent");
        assert_eq!(inspect["parents"][0]["basedOn"], Value::Null);

        // Cycles are refused.
        assert!(s.execute("layout.parents.options", &json!({"parent": "A", "basedOn": "B"})).is_err());
        assert!(s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": "B-Opening"})).is_err());
        assert!(s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": "Z"})).is_err());

        s.execute("edit.undo", &json!({})).unwrap();
        assert!(paper(page(&s, 1).pixel(50, 100)), "undo clears Based on Parent");
        s.execute("edit.redo", &json!({})).unwrap();
        s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": null})).unwrap();
        assert_eq!(s.execute("document.inspect", &json!({})).unwrap()["parents"][1]["basedOn"], Value::Null);
    }

    /// A's page-number marker shown on parent XYZ (based on A) reads XYZ, as markers on XYZ's own items do.
    #[test]
    fn base_parent_markers_read_the_showing_parent() {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({"pages": 1, "facingPages": false})).unwrap();
        s.execute("layout.parents.new", &json!({"prefix": "XYZ"})).unwrap();
        s.execute("layout.parents.options", &json!({"parent": "XYZ", "basedOn": "A"})).unwrap();
        let marker = designcraft_doc::story::PAGE_NUMBER.to_string();
        let r = s
            .execute("frame.create", &json!({"spread": {"kind": "parent", "index": 0}, "rect": [72, 30, 500, 60], "content": "text", "text": marker}))
            .unwrap();
        let d = s.doc().unwrap().doc.clone();
        let sid = d.item(designcraft_doc::ItemId(r["id"].as_u64().unwrap())).unwrap().text_frame().unwrap().story;
        let glyphs = |on| -> usize {
            let cs = s.cache.get_on(&d, sid, on);
            cs.frames.iter().flat_map(|f| f.lines.iter()).map(|l| l.glyphs.iter().filter(|g| g.visible && g.adv > 0.0).count()).sum()
        };
        assert_eq!(glyphs(designcraft_compose::ShownOn::Own), 1, "A");
        assert_eq!(glyphs(designcraft_compose::ShownOn::Parent(1)), 3, "XYZ");
    }

    /// A file whose parents are based on each other opens, with the cycle broken and reported.
    #[test]
    fn opening_a_parent_cycle_breaks_it_with_a_warning() {
        let mut s = crate::Session::new();
        s.execute("file.new", &json!({"pages": 1})).unwrap();
        s.execute("layout.parents.new", &json!({"prefix": "B"})).unwrap();
        let mut d = s.doc().unwrap().doc.as_ref().clone();
        let (a, b) = (d.parents[0].id, d.parents[1].id);
        std::sync::Arc::make_mut(&mut d.parents[0]).parent.as_mut().unwrap().based_on = Some(b);
        std::sync::Arc::make_mut(&mut d.parents[1]).parent.as_mut().unwrap().based_on = Some(a);
        let b64 = crate::cmd::base64_encode(&crate::cmd::to_bytes(&d).unwrap());
        let r = s.execute("file.openBytes", &json!({"name": "cycle", "base64": b64})).unwrap();
        assert!(r["warnings"].to_string().contains("cycle"), "{r}");
        let d = &s.doc().unwrap().doc;
        assert_eq!(d.parents[0].parent.as_ref().unwrap().based_on, None);
        assert_eq!(d.parents[1].parent.as_ref().unwrap().based_on, Some(a));
    }
}