GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
//! Custom arrowheads (`cmd/arrowheads.rs`): heads read from the arrowheads file's symbols, listed,
//! set with `stroke.set`, reloaded when the file is saved, and kept with the documents that use
//! them.

use std::sync::Arc;

use serde_json::json;
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, Arrowhead, Document, Node, StrokeLayer, Symbol, SymbolRegistration};
use vectorcraft_geom::{PathData, Point, SubPath};

use crate::cmd::arrowheads::{self, heads_of};
use crate::*;

fn polygon(pts: &[(f64, f64)], ap: Appearance) -> Node {
    let pts: Vec<Point> = pts.iter().map(|&(x, y)| Point::new(x, y)).collect();
    Node::path(NodeId(0), PathData::single(SubPath::polyline(&pts, true)), ap)
}

fn add_symbol(d: &mut Document, name: &str, art: Node) {
    let art = d.reid(&art);
    d.symbols.push(Symbol { name: name.into(), art: Arc::new(art), dynamic: false });
}

fn filled() -> Appearance {
    Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 1.0)
}

/// A folder of its own for test `name`, emptied.
fn folder(name: &str) -> std::path::PathBuf {
    let dir = std::env::temp_dir().join(format!("vectorcraft-arrowheads-{name}-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    dir
}

fn session_with_line() -> (Session, NodeId) {
    let mut s = Session::new();
    s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
    let r = s.execute("shape.line", &json!({"x1": 10, "y1": 100, "x2": 150, "y2": 100})).unwrap();
    (s, NodeId(r["id"].as_u64().unwrap()))
}

fn stroke(s: &Session, id: NodeId) -> StrokeLayer {
    s.doc().unwrap().doc.node(id).unwrap().appearance.stroke().unwrap().clone()
}

#[test]
fn each_symbol_is_a_head_pointing_right_with_its_tip_at_the_registration_point() {
    let mut d = Document::new(100.0, 100.0);
    // 20 high, so a unit is 5 pt: tip on the right edge's middle.
    add_symbol(&mut d, "Wedge", polygon(&[(0.0, -10.0), (20.0, 0.0), (0.0, 10.0)], filled()));
    d.set_symbol_registration("Wedge", SymbolRegistration(5));
    // A stroke alone paints its outline: a 10 × 4 band, tip at its centre (the default).
    let mut line = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 4.0);
    line.stroke_mut().unwrap().cap = vectorcraft_doc::LineCap::Butt;
    let band = Node::path(NodeId(0), PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(10.0, 0.0)], false)), line);
    add_symbol(&mut d, "Band", band);
    // Neither filled nor stroked: no head.
    add_symbol(&mut d, "Ghost", polygon(&[(0.0, 0.0), (5.0, 0.0), (5.0, 5.0)], Appearance::default()));
    // Far longer than wide.
    add_symbol(&mut d, "Needle", polygon(&[(0.0, 0.0), (1000.0, 0.5), (0.0, 1.0)], filled()));
    // A fill at 0 % opacity paints nothing.
    let mut clear = filled();
    if let Some(vectorcraft_doc::AppearanceItem::Fill(f)) = clear.items.first_mut() {
        f.opacity = 0.0;
    }
    add_symbol(&mut d, "Clear", polygon(&[(0.0, 0.0), (5.0, 0.0), (5.0, 5.0)], clear));
    // More anchors than a symbol's art may have: skipped before its shapes are united.
    let dense: Vec<(f64, f64)> = (0..=arrowheads::MAX_ART_ANCHORS).map(|i| ((i as f64).cos(), (i as f64).sin())).collect();
    add_symbol(&mut d, "Dense", polygon(&dense, filled()));
    // A 20 × 4 bar clipped to a 4 × 4 square: a 4 × 4 head.
    let mut mask = polygon(&[(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0)], Appearance::default());
    if let NodeKind::Path { clipping, .. } = &mut mask.kind {
        *clipping = true;
    }
    let bar = polygon(&[(0.0, 0.0), (20.0, 0.0), (20.0, 4.0), (0.0, 4.0)], filled());
    add_symbol(&mut d, "Clipped", Node::new(NodeId(0), NodeKind::Group { children: vec![Arc::new(mask), Arc::new(bar)], clip: true }));
    // An 8 × 4 bar grown by 2 pt on every side (Offset Path): 12 × 8, so 6 units long.
    let mut grown = filled();
    grown.effects.push(vectorcraft_doc::Effect { id: "path.offsetPath".into(), params: json!({"offset": 2}), visible: true });
    add_symbol(&mut d, "Grown", polygon(&[(0.0, 0.0), (8.0, 0.0), (8.0, 4.0), (0.0, 4.0)], grown));
    // The same effect on the fill alone.
    let mut fill_grown = filled();
    fill_grown.items[0].effects_mut().push(vectorcraft_doc::Effect { id: "path.offsetPath".into(), params: json!({"offset": 2}), visible: true });
    add_symbol(&mut d, "Fill Grown", polygon(&[(0.0, 0.0), (8.0, 0.0), (8.0, 4.0), (0.0, 4.0)], fill_grown));
    // And on a group holding the bar.
    let mut group = Node::group(NodeId(0), vec![Arc::new(polygon(&[(0.0, 0.0), (8.0, 0.0), (8.0, 4.0), (0.0, 4.0)], filled()))]);
    group.appearance.effects.push(vectorcraft_doc::Effect { id: "path.offsetPath".into(), params: json!({"offset": 2}), visible: true });
    add_symbol(&mut d, "Group Grown", group);
    // A clipping path stroked 2 pt: its stroke paints unclipped and does not widen the clip.
    let mut frame = polygon(&[(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0)], Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 2.0));
    if let NodeKind::Path { clipping, .. } = &mut frame.kind {
        *clipping = true;
    }
    let bar = polygon(&[(0.0, 0.0), (20.0, 0.0), (20.0, 4.0), (0.0, 4.0)], filled());
    add_symbol(&mut d, "Framed", Node::new(NodeId(0), NodeKind::Group { children: vec![Arc::new(frame), Arc::new(bar)], clip: true }));
    // A group's own fill paints its unpainted 8 × 4 member.
    let mut painted_group = Node::group(NodeId(0), vec![Arc::new(polygon(&[(0.0, 0.0), (8.0, 0.0), (8.0, 4.0), (0.0, 4.0)], Appearance::default()))]);
    painted_group.appearance = filled().into();
    add_symbol(&mut d, "Group Fill", painted_group);
    // A 10 × 4 band stroked with a gradient along it.
    let gradient = Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(vectorcraft_color::Gradient::default())));
    let mut along = Appearance::basic(Paint::None, gradient, 4.0);
    if let Some(st) = along.stroke_mut() {
        (st.cap, st.gradient_mode) = (vectorcraft_doc::LineCap::Butt, vectorcraft_doc::StrokeGradientMode::Along);
    }
    let band = Node::path(NodeId(0), PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(10.0, 0.0)], false)), along);
    add_symbol(&mut d, "Gradient Band", band);
    // An 8 × 4 mesh of two patches whose right one is fully transparent: a 4 × 4 head.
    let corners = vectorcraft_doc::live::grid_points(vectorcraft_geom::Rect::new(0.0, 0.0, 8.0, 4.0), 1, 2);
    let points = corners
        .iter()
        .map(|&p| vectorcraft_doc::MeshPoint { p, color: Color::BLACK, opacity: if p.x > 1.0 { 0.0 } else { 1.0 }, handles: Default::default() })
        .collect();
    let mesh = vectorcraft_doc::GradientMesh { rows: 1, cols: 2, points };
    add_symbol(&mut d, "Half Mesh", Node::new(NodeId(0), NodeKind::Mesh(mesh)));
    // An effect on the file's layer is not part of any symbol.
    Arc::make_mut(&mut d.layers[0]).appearance.effects.push(vectorcraft_doc::Effect {
        id: "path.offsetPath".into(),
        params: json!({"offset": 5}),
        visible: true,
    });
    let read = heads_of(&d);
    let names: Vec<&str> = read.heads.iter().map(|h| h.name.as_str()).collect();
    assert_eq!(names, ["Wedge", "Band", "Clipped", "Grown", "Fill Grown", "Group Grown", "Framed", "Group Fill", "Gradient Band", "Half Mesh"]);
    let b = read.heads[9].path.bounds().unwrap();
    assert!((b.width() - 4.0).abs() < 1e-3 && (b.height() - 4.0).abs() < 1e-3, "the mesh's painted patch: {b:?}");
    let b = read.heads[7].path.bounds().unwrap();
    assert!((b.width() - 8.0).abs() < 1e-3 && (b.height() - 4.0).abs() < 1e-3, "the group's fill: {b:?}");
    let (g, plain) = (read.heads[8].path.bounds().unwrap(), read.heads[1].path.bounds().unwrap());
    let near = |a: f64, b: f64| (a - b).abs() < 1e-3;
    assert!(near(g.x0, plain.x0) && near(g.x1, plain.x1) && near(g.y0, plain.y0) && near(g.y1, plain.y1), "the gradient stroke's outline: {g:?}");
    let framed = read.heads[6].path.to_bezpath();
    let b = vectorcraft_geom::Shape::bounding_box(&framed);
    assert!((b.width() - 4.0).abs() < 1e-3 && (b.height() - 4.0).abs() < 1e-3, "6 × 6 with the stroke: {b:?}");
    assert_ne!(vectorcraft_geom::Shape::winding(&framed, Point::new(0.1, 0.1)), 0, "the clipped bar fills the middle");
    for h in &read.heads[3..6] {
        let b = h.path.bounds().unwrap();
        assert!((b.width() - 6.0).abs() < 1e-3 && (b.height() - 4.0).abs() < 1e-3, "{}: the effect's outline: {b:?}", h.name);
    }
    let skipped: Vec<&str> = read.skipped.iter().map(|(n, _)| n.as_str()).collect();
    assert_eq!(skipped, ["Ghost", "Needle", "Clear", "Dense"], "{:?}", read.skipped);
    let b = read.heads[2].path.bounds().unwrap();
    assert!((b.width() - 4.0).abs() < 1e-3 && (b.height() - 4.0).abs() < 1e-3, "clipped to the square: {b:?}");
    let b = read.heads[0].path.bounds().unwrap();
    assert!(b.x0.abs() < 1e-6 && (b.x1 - 4.0).abs() < 1e-6 && (b.y0 + 2.0).abs() < 1e-6 && (b.y1 - 2.0).abs() < 1e-6, "{b:?}");
    assert!((read.heads[0].reach() - 4.0f64.hypot(2.0)).abs() < 1e-6);
    let b = read.heads[1].path.bounds().unwrap();
    assert!((b.x0 + 5.0).abs() < 1e-3 && (b.x1 - 5.0).abs() < 1e-3 && (b.y0 + 2.0).abs() < 1e-3 && (b.y1 - 2.0).abs() < 1e-3, "{b:?}");
}

#[test]
fn the_arrowheads_file_is_made_opened_and_reloaded_when_saved() {
    let dir = folder("edit");
    let file = dir.join(arrowheads::FILE_NAME).to_string_lossy().to_string();
    let (mut s, id) = session_with_line();
    s.attach_arrowheads_file(file.clone());
    let list = s.execute("stroke.arrowheads.list", &json!({})).unwrap();
    assert_eq!((list["arrowheads"].as_array().unwrap().len(), list["file"].as_str()), (0, Some(file.as_str())));
    assert!(s.execute("stroke.set", &json!({"endArrow": {"custom": "Example Arrowhead"}})).is_err(), "no such head yet");
    let line_doc = s.doc().unwrap().uid;
    let r = s.execute("stroke.arrowheads.edit", &json!({})).unwrap();
    assert_eq!(r["created"], true);
    assert_eq!(s.doc().unwrap().path.as_deref(), Some(file.as_str()), "the file is the active document");
    let list = s.execute("stroke.arrowheads.list", &json!({})).unwrap();
    assert_eq!(list["arrowheads"][0]["name"], "Example Arrowhead");
    // A second head drawn in the file is listed once the file is saved.
    let st = s.doc_mut().unwrap();
    let d = Arc::make_mut(&mut st.doc);
    add_symbol(d, "Square", polygon(&[(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0)], filled()));
    assert_eq!(s.execute("stroke.arrowheads.list", &json!({})).unwrap()["arrowheads"].as_array().unwrap().len(), 1);
    s.execute("document.save", &json!({})).unwrap();
    let list = s.execute("stroke.arrowheads.list", &json!({})).unwrap();
    let names: Vec<&str> = list["arrowheads"].as_array().unwrap().iter().filter_map(|h| h["name"].as_str()).collect();
    assert_eq!(names, ["Example Arrowhead", "Square"]);
    // Editing again from the line's document brings the open file to the front, without making
    // it anew or opening it twice.
    s.execute("document.activate", &json!({"index": 0})).unwrap();
    assert_eq!(s.doc().unwrap().uid, line_doc);
    assert_eq!(s.execute("stroke.arrowheads.edit", &json!({})).unwrap()["created"], false);
    assert_eq!((s.documents().len(), s.doc().unwrap().path.as_deref()), (2, Some(file.as_str())));
    // The line takes the head with its art.
    s.execute("document.activate", &json!({"index": 0})).unwrap();
    s.execute("stroke.set", &json!({"ids": [id.0], "endArrow": {"custom": "Square"}})).unwrap();
    let Some(Arrowhead::Custom(c)) = stroke(&s, id).end_arrow else { panic!("a custom head") };
    assert_eq!(c.name, "Square");
    assert!(s.execute("stroke.set", &json!({"endArrow": {"custom": 3}})).is_err());
    assert!(s.execute("stroke.set", &json!({"endArrow": {"custom": "Circle"}})).is_err());
    // A head given with its art is refused when the art could not be drawn.
    let mut far = serde_json::to_value(Arrowhead::Custom(c.clone())).unwrap();
    far["Custom"]["path"] = serde_json::to_value(PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(1e6, 1.0)], true))).unwrap();
    assert!(s.execute("stroke.set", &json!({"ids": [id.0], "endArrow": far})).is_err());
    let mut empty = serde_json::to_value(Arrowhead::Custom(c)).unwrap();
    empty["Custom"]["path"] = json!({"subpaths": []});
    assert!(s.execute("stroke.set", &json!({"ids": [id.0], "endArrow": empty})).is_err());
    // One anchor, or anchors on one line, fill nothing.
    for pts in [vec![Point::new(1.0, 1.0)], vec![Point::new(0.0, 0.0), Point::new(2.0, 0.0), Point::new(4.0, 0.0)]] {
        let mut flat =
            serde_json::to_value(Arrowhead::Custom(Arc::new(vectorcraft_doc::CustomArrowhead::new("Flat".into(), PathData::default())))).unwrap();
        flat["Custom"]["path"] = serde_json::to_value(PathData::single(SubPath::polyline(&pts, false))).unwrap();
        assert!(s.execute("stroke.set", &json!({"ids": [id.0], "endArrow": flat})).is_err(), "{pts:?}");
    }
    // A lone anchor draws no segment, whatever its handles.
    let mut lone = vectorcraft_geom::Anchor::corner(Point::new(1.0, 0.0));
    (lone.h_in, lone.h_out) = (Point::new(0.0, 1.0), Point::new(2.0, -1.0));
    let mut handles =
        serde_json::to_value(Arrowhead::Custom(Arc::new(vectorcraft_doc::CustomArrowhead::new("Lone".into(), PathData::default())))).unwrap();
    handles["Custom"]["path"] = serde_json::to_value(PathData::single(SubPath::new(vec![lone], true))).unwrap();
    assert!(s.execute("stroke.set", &json!({"ids": [id.0], "endArrow": handles.clone()})).is_err(), "a lone anchor");
    // Two equal squares winding opposite ways cancel out.
    let sq = [Point::new(0.0, -1.0), Point::new(2.0, -1.0), Point::new(2.0, 1.0), Point::new(0.0, 1.0)];
    let back: Vec<Point> = sq.iter().rev().copied().collect();
    let cancel = PathData::new(vec![SubPath::polyline(&sq, true), SubPath::polyline(&back, true)]);
    handles["Custom"]["path"] = serde_json::to_value(cancel).unwrap();
    assert!(s.execute("stroke.set", &json!({"ids": [id.0], "endArrow": handles})).is_err(), "opposite squares");
    // A bow tie's lobes wind opposite ways, so its signed area is 0, and it still fills both.
    let tie = [Point::new(0.0, -1.0), Point::new(2.0, 1.0), Point::new(2.0, -1.0), Point::new(0.0, 1.0)];
    let mut bow =
        serde_json::to_value(Arrowhead::Custom(Arc::new(vectorcraft_doc::CustomArrowhead::new("Bow".into(), PathData::default())))).unwrap();
    bow["Custom"]["path"] = serde_json::to_value(PathData::single(SubPath::polyline(&tie, true))).unwrap();
    assert!(matches!(stroke(&s, id).end_arrow, Some(Arrowhead::Custom(h)) if h.name == "Square"), "the head stays as it was");
    s.execute("stroke.set", &json!({"ids": [id.0], "endArrow": bow.clone()})).unwrap();
    assert!(matches!(stroke(&s, id).end_arrow, Some(Arrowhead::Custom(h)) if h.name == "Bow"));
    // So does a very thin bar.
    let bar = [Point::new(0.0, 0.0), Point::new(4.0, 0.0), Point::new(4.0, 0.001), Point::new(0.0, 0.001)];
    bow["Custom"]["path"] = serde_json::to_value(PathData::single(SubPath::polyline(&bar, true))).unwrap();
    s.execute("stroke.set", &json!({"ids": [id.0], "endArrow": bow})).unwrap();
    let Some(Arrowhead::Custom(h)) = stroke(&s, id).end_arrow else { panic!("a custom head") };
    assert_eq!(h.path.anchor_count(), 4, "the thin bar");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn a_document_keeps_its_custom_heads_without_the_arrowheads_file() {
    let (mut s, id) = session_with_line();
    let mut d = Document::new(100.0, 100.0);
    add_symbol(&mut d, "Wedge", polygon(&[(0.0, -10.0), (20.0, 0.0), (0.0, 10.0)], filled()));
    let head = Arrowhead::Custom(Arc::new(heads_of(&d).heads.remove(0)));
    // As document.inspect reports it, so it reads back unchanged.
    s.execute("stroke.set", &json!({"startArrow": head, "endArrow": "Triangle"})).unwrap();
    assert_eq!(stroke(&s, id).start_arrow, Some(head.clone()));
    let inspect = s.execute("document.inspect", &json!({})).unwrap().to_string();
    assert!(inspect.contains("\"Wedge\""), "inspect names the head");
    let ink = |s: &Session| {
        vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 200, 200, vectorcraft_geom::Affine::IDENTITY, &Default::default())
    };
    let with_head = ink(&s);
    // Saved and opened in a session that has no arrowheads file: the head is drawn the same.
    let saved = s.execute("document.export", &json!({"format": "vectorcraft"})).unwrap()["dataBase64"].clone();
    let mut o = Session::new();
    o.execute("document.open", &json!({"name": "a.vectorcraft", "dataBase64": saved})).unwrap();
    assert_eq!(stroke(&o, id).start_arrow, Some(head));
    assert_eq!(ink(&o).pixels, with_head.pixels);
    // SVG and PDF write it as they write the built-in heads.
    let svg = |s: &mut Session| s.execute("document.export", &json!({"format": "svg"})).unwrap()["dataBase64"].as_str().unwrap().len();
    let headed = svg(&mut o);
    o.execute("stroke.set", &json!({"ids": [id.0], "startArrow": null})).unwrap();
    assert!(headed > svg(&mut o), "the head is in the SVG");
    // Undo puts it back.
    o.execute("edit.undo", &json!({})).unwrap();
    assert!(matches!(stroke(&o, id).start_arrow, Some(Arrowhead::Custom(_))));
}

#[test]
fn an_unreadable_arrowheads_file_lists_no_heads_and_says_why() {
    let dir = folder("bad");
    let file = dir.join(arrowheads::FILE_NAME);
    std::fs::write(&file, b"not a drawing").unwrap();
    let mut s = Session::new();
    s.attach_arrowheads_file(file.to_string_lossy().to_string());
    let list = s.execute("stroke.arrowheads.list", &json!({})).unwrap();
    assert!(list["arrowheads"].as_array().unwrap().is_empty());
    assert!(list["error"].is_string(), "{list}");
    assert!(s.execute("stroke.arrowheads.reload", &json!({})).is_err());
    // A folder in its place is not read either.
    std::fs::remove_file(&file).unwrap();
    std::fs::create_dir(&file).unwrap();
    assert!(s.execute("stroke.arrowheads.reload", &json!({})).is_err());
    let _ = std::fs::remove_dir_all(&dir);
    // Without a file (the web, runs without preferences) there is nothing to edit.
    let mut bare = Session::new();
    assert!(bare.execute("stroke.arrowheads.edit", &json!({})).is_err());
    assert_eq!(bare.execute("stroke.arrowheads.list", &json!({})).unwrap()["file"], serde_json::Value::Null);
}

/// Automation roots that grant reading `read` alone.
fn read_roots(read: &[&std::path::Path]) -> Arc<crate::file_access::AutomationRoots> {
    crate::file_access::AutomationRoots::new(read, &[]).unwrap().unwrap()
}

#[test]
fn an_agent_outside_the_arrowheads_files_folder_sees_its_file_name_alone_and_cannot_reload_it() {
    let dir = folder("roots-list");
    let (prefs, other) = (dir.join("prefs"), dir.join("other"));
    std::fs::create_dir_all(&prefs).unwrap();
    std::fs::create_dir_all(&other).unwrap();
    let file = prefs.join(arrowheads::FILE_NAME);
    std::fs::write(&file, b"not a drawing").unwrap();
    let (file, prefs_text) = (file.to_string_lossy().to_string(), prefs.to_string_lossy().to_string());
    let mut s = Session::new();
    s.attach_arrowheads_file(file.clone());
    let (outside, inside) = (read_roots(&[&other]), read_roots(&[&prefs]));
    let list = crate::file_access::confine(Some(&outside), || s.execute("stroke.arrowheads.list", &json!({}))).unwrap();
    assert_eq!(list["file"], serde_json::Value::Null, "{list}");
    let error = list["error"].as_str().unwrap();
    assert!(error.starts_with(arrowheads::FILE_NAME) && !error.contains(&prefs_text), "{error}");
    let list = crate::file_access::confine(Some(&inside), || s.execute("stroke.arrowheads.list", &json!({}))).unwrap();
    assert_eq!(list["file"].as_str(), Some(file.as_str()));
    assert!(list["error"].as_str().unwrap().starts_with(&file), "{list}");
    // A good file now: an agent outside the folder cannot have it read.
    std::fs::write(&file, vectorcraft_format::save_file(&arrowheads::starter())).unwrap();
    let e = crate::file_access::confine(Some(&outside), || s.execute("stroke.arrowheads.reload", &json!({}))).unwrap_err().to_string();
    assert!(e.contains("outside the read root") && e.ends_with(arrowheads::FILE_NAME) && !e.contains(&prefs_text), "{e}");
    let list = s.execute("stroke.arrowheads.list", &json!({})).unwrap();
    assert!(list["arrowheads"].as_array().unwrap().is_empty() && list["error"].is_string(), "not read again: {list}");
    let r = crate::file_access::confine(Some(&inside), || s.execute("stroke.arrowheads.reload", &json!({}))).unwrap();
    assert_eq!(r["count"], 1);
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn an_agent_edits_the_arrowheads_file_only_inside_its_read_roots() {
    let dir = folder("roots-edit");
    let (prefs, other) = (dir.join("prefs"), dir.join("other"));
    std::fs::create_dir_all(&other).unwrap();
    let file = prefs.join(arrowheads::FILE_NAME).to_string_lossy().to_string();
    let prefs_text = prefs.to_string_lossy().to_string();
    let (mut s, _) = session_with_line();
    s.attach_arrowheads_file(file.clone());
    let line_doc = s.doc().unwrap().uid;
    let outside = read_roots(&[&other]);
    let edit = |s: &mut Session, roots: &Arc<crate::file_access::AutomationRoots>| {
        crate::file_access::confine(Some(roots), || s.execute("stroke.arrowheads.edit", &json!({})))
    };
    // Refused before the folder or the file is made, or anything is opened.
    let e = edit(&mut s, &outside).unwrap_err().to_string();
    assert!(e.ends_with(arrowheads::FILE_NAME) && !e.contains(&prefs_text), "{e}");
    assert!(!prefs.exists(), "no folder made");
    assert_eq!((s.documents().len(), s.doc().unwrap().uid), (1, line_doc));
    // From the Stroke panel menu (no roots), the file is made and opened.
    assert_eq!(s.execute("stroke.arrowheads.edit", &json!({})).unwrap()["created"], true);
    assert_eq!(s.documents().len(), 2);
    // Open already: still not brought to the front for an agent outside the folder.
    s.execute("document.activate", &json!({"index": 0})).unwrap();
    assert!(edit(&mut s, &outside).is_err());
    assert_eq!((s.documents().len(), s.doc().unwrap().uid), (2, line_doc));
    // Inside the read roots: opened under them, with its path.
    let inside = read_roots(&[&prefs]);
    let mut agent = Session::new();
    agent.attach_arrowheads_file(file.clone());
    let r = edit(&mut agent, &inside).unwrap();
    assert_eq!((r["path"].as_str(), &r["created"]), (Some(file.as_str()), &json!(false)));
    let st = agent.doc().unwrap();
    assert_eq!(st.path.as_deref(), Some(file.as_str()));
    assert!(st.opened_by.as_ref().is_some_and(|r| Arc::ptr_eq(r, &inside)), "opened under the agent's roots");
    // A missing file inside the roots is still made first.
    let fresh = dir.join("fresh").join(arrowheads::FILE_NAME).to_string_lossy().to_string();
    let mut agent = Session::new();
    agent.attach_arrowheads_file(fresh.clone());
    let r = edit(&mut agent, &read_roots(&[&dir])).unwrap();
    assert_eq!(r["created"], true);
    assert!(std::path::Path::new(&fresh).is_file());
    assert_eq!(agent.doc().unwrap().path.as_deref(), Some(fresh.as_str()));
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn the_heads_listed_after_a_save_are_read_from_the_file_and_editing_keeps_it() {
    let dir = folder("saved");
    let file = dir.join(arrowheads::FILE_NAME).to_string_lossy().to_string();
    let (mut s, _) = session_with_line();
    s.attach_arrowheads_file(file.clone());
    assert_eq!(s.execute("stroke.arrowheads.edit", &json!({})).unwrap()["created"], true);
    // A speck that saving rounds to a point is a head only before the save.
    let st = s.doc_mut().unwrap();
    add_symbol(Arc::make_mut(&mut st.doc), "Speck", polygon(&[(0.0, 0.0), (0.3, 0.1), (0.0, 0.2)], filled()));
    assert!(heads_of(&s.doc().unwrap().doc).heads.iter().any(|h| h.name == "Speck"), "a head before rounding");
    s.execute("document.save", &json!({"precision": 0})).unwrap();
    let list = s.execute("stroke.arrowheads.list", &json!({})).unwrap();
    let names: Vec<&str> = list["arrowheads"].as_array().unwrap().iter().filter_map(|h| h["name"].as_str()).collect();
    assert_eq!(names, ["Example Arrowhead"]);
    assert_eq!(list["skipped"][0]["name"], "Speck", "{list}");
    // Editing again leaves the file as it is.
    let saved = std::fs::read(&file).unwrap();
    s.execute("document.activate", &json!({"index": 0})).unwrap();
    assert_eq!(s.execute("stroke.arrowheads.edit", &json!({})).unwrap()["created"], false);
    assert_eq!(std::fs::read(&file).unwrap(), saved, "the file is left as it was");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn an_arrowheads_file_that_unpacks_past_the_size_limit_is_not_read() {
    let dir = folder("unpacked");
    let file = dir.join(arrowheads::FILE_NAME);
    let mut d = arrowheads::starter();
    d.title = "a".repeat(arrowheads::MAX_FILE_BYTES as usize);
    let bytes = vectorcraft_format::save_with(&d, &vectorcraft_format::SaveOptions { compress: true, ..Default::default() }).unwrap();
    assert!((bytes.len() as u64) < arrowheads::MAX_FILE_BYTES / 16, "compressed small: {}", bytes.len());
    std::fs::write(&file, &bytes).unwrap();
    let mut s = Session::new();
    s.attach_arrowheads_file(file.to_string_lossy().to_string());
    let list = s.execute("stroke.arrowheads.list", &json!({})).unwrap();
    assert!(list["arrowheads"].as_array().unwrap().is_empty(), "{}", list["arrowheads"]);
    assert!(list["error"].is_string(), "{}", list["error"]);
    // The same head in a file of an ordinary size is read.
    std::fs::write(&file, vectorcraft_format::save_file(&arrowheads::starter())).unwrap();
    assert_eq!(s.execute("stroke.arrowheads.reload", &json!({})).unwrap()["count"], 1);
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn a_symbol_whose_shapes_cannot_be_combined_is_skipped() {
    let wedge = || Arc::new(polygon(&[(0.0, -10.0), (20.0, 0.0), (0.0, 10.0)], filled()));
    // Too far out for the shape operations to measure: the union would leave it out.
    let far = || Arc::new(polygon(&[(0.0, 0.0), (1e200, 0.0), (0.0, 1e200)], filled()));
    let mut d = Document::new(100.0, 100.0);
    add_symbol(&mut d, "Wedge", (*wedge()).clone());
    add_symbol(&mut d, "Broken", Node::group(NodeId(0), vec![wedge(), far()]));
    // The same as clipped art.
    let mut mask = polygon(&[(0.0, -10.0), (20.0, -10.0), (20.0, 10.0), (0.0, 10.0)], Appearance::default());
    if let NodeKind::Path { clipping, .. } = &mut mask.kind {
        *clipping = true;
    }
    add_symbol(&mut d, "Broken Clip", Node::new(NodeId(0), NodeKind::Group { children: vec![Arc::new(mask), wedge(), far()], clip: true }));
    let read = heads_of(&d);
    let names: Vec<&str> = read.heads.iter().map(|h| h.name.as_str()).collect();
    assert_eq!(names, ["Wedge"]);
    let skipped: Vec<&str> = read.skipped.iter().map(|(n, _)| n.as_str()).collect();
    assert_eq!(skipped, ["Broken", "Broken Clip"], "{:?}", read.skipped);
}

#[test]
fn a_group_used_as_the_clipping_path_adds_none_of_its_own_fills() {
    // A group holding a filled 20 × 4 bar clips a filled 4 × 4 square: the group paints nothing as
    // the clipping path, so the head is the square alone.
    let bar = polygon(&[(0.0, 0.0), (20.0, 0.0), (20.0, 4.0), (0.0, 4.0)], filled());
    let mask = Node::group(NodeId(0), vec![Arc::new(bar)]);
    let square = polygon(&[(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0)], filled());
    let mut d = Document::new(100.0, 100.0);
    add_symbol(&mut d, "Group Clip", Node::new(NodeId(0), NodeKind::Group { children: vec![Arc::new(mask), Arc::new(square)], clip: true }));
    let read = heads_of(&d);
    assert_eq!(read.heads.len(), 1, "{:?}", read.skipped);
    let b = read.heads[0].path.bounds().unwrap();
    assert!((b.width() - 4.0).abs() < 1e-3 && (b.height() - 4.0).abs() < 1e-3, "the square alone: {b:?}");
}