//! 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 = 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 = 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::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::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:?}"); }