GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
//! Symbol editing mode (`symbol.edit`, `symbol.exitEditing`).

use serde_json::{Value, json};
use vectorcraft_doc::{Node, NodeKind};
use vectorcraft_geom::Rect;

use crate::*;

fn run(s: &mut Session, cmd: &str, p: Value) -> Value {
    s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
}

fn id(v: &Value) -> NodeId {
    NodeId(v["id"].as_u64().expect("an id"))
}

/// A 400 × 300 document with the 80 × 40 symbol "Box" made from a rectangle at (100, 50), its
/// instance there and a second instance centered on (300, 200).
fn two_instances() -> (Session, NodeId, NodeId) {
    let mut s = Session::new();
    run(&mut s, "file.new", json!({"width": 400, "height": 300}));
    run(&mut s, "shape.rectangle", json!({"x": 100, "y": 50, "width": 80, "height": 40}));
    let first = id(&run(&mut s, "symbol.new", json!({"name": "Box"})));
    let second = id(&run(&mut s, "symbol.place", json!({"name": "Box", "x": 300, "y": 200})));
    (s, first, second)
}

/// The bounds of `id` as the document measures them: an instance's by its symbol's art.
fn bounds(s: &Session, id: NodeId) -> Rect {
    s.doc().unwrap().doc.bounds_of(&[id], false).expect("bounds")
}

fn close(a: Rect, b: Rect) -> bool {
    [(a.x0, b.x0), (a.y0, b.y0), (a.x1, b.x1), (a.y1, b.y1)].iter().all(|(x, y)| (x - y).abs() < 1e-6)
}

fn is_instance(s: &Session, id: NodeId) -> bool {
    s.doc().unwrap().doc.node(id).is_some_and(|n| matches!(&n.kind, NodeKind::SymbolInstance { symbol, .. } if symbol == "Box"))
}

/// The objects on the editing layer.
fn layer_art(s: &Session) -> Vec<NodeId> {
    let st = s.doc().unwrap();
    let layer = st.doc.symbol_edit.as_ref().expect("editing a symbol").layer;
    st.doc.node(layer).and_then(|l| l.children()).map(|c| c.iter().map(|n| n.id).collect()).unwrap_or_default()
}

#[test]
fn edit_symbol_edits_the_art_where_the_instance_shows_it_and_every_instance_follows() {
    let (mut s, first, second) = two_instances();
    run(&mut s, "select.set", json!({"ids": [first.0]}));
    let r = run(&mut s, "symbol.edit", json!({}));
    assert_eq!((r["name"].as_str(), r["id"].as_u64()), (Some("Box"), Some(first.0)));
    let layer = NodeId(r["layer"].as_u64().unwrap());
    let st = s.doc().unwrap();
    assert_eq!(st.isolation, Some(layer));
    assert_eq!(st.active_layer, Some(layer));
    // The instance stays linked: editing the symbol doesn't expand it.
    assert!(is_instance(&s, first) && is_instance(&s, second));
    let art = layer_art(&s);
    assert_eq!(art.len(), 1);
    assert!(close(bounds(&s, art[0]), Rect::new(100.0, 50.0, 180.0, 90.0)), "{:?}", bounds(&s, art[0]));
    assert_eq!(s.doc().unwrap().selection.objects, art);
    // An edit of the art reaches both instances at once, each at its own place.
    run(&mut s, "object.move", json!({"dx": 10, "dy": 0}));
    assert!(close(bounds(&s, first), Rect::new(110.0, 50.0, 190.0, 90.0)), "{:?}", bounds(&s, first));
    assert!(close(bounds(&s, second), Rect::new(270.0, 180.0, 350.0, 220.0)), "{:?}", bounds(&s, second));
    // New art goes into the symbol.
    run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 10, "height": 10}));
    assert_eq!(layer_art(&s).len(), 2);
    assert!(close(bounds(&s, second), Rect::new(260.0, 180.0, 350.0, 240.0)), "{:?}", bounds(&s, second));
    let r = run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(r["name"], "Box");
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none());
    assert!(st.doc.node(layer).is_none(), "the editing layer is gone");
    assert_eq!(st.selection.objects, vec![first]);
    assert!(is_instance(&s, first));
    assert!(close(bounds(&s, second), Rect::new(260.0, 180.0, 350.0, 240.0)), "{:?}", bounds(&s, second));
}

#[test]
fn an_instance_transform_places_the_art_and_edits_go_back_through_it() {
    let (mut s, first, second) = two_instances();
    // The second instance twice as large: a 20 pt move there is a 10 pt move of the symbol's art.
    run(&mut s, "select.set", json!({"ids": [second.0]}));
    run(&mut s, "object.scale", json!({"sx": 200, "sy": 200, "origin": [300, 200]}));
    let big = bounds(&s, second);
    assert!(close(big, Rect::new(220.0, 160.0, 380.0, 240.0)), "{big:?}");
    run(&mut s, "symbol.edit", json!({"id": second.0}));
    let art = layer_art(&s);
    assert!(close(bounds(&s, art[0]), big), "{:?}", bounds(&s, art[0]));
    run(&mut s, "object.move", json!({"dx": 20, "dy": 0}));
    assert!(close(bounds(&s, second), Rect::new(240.0, 160.0, 400.0, 240.0)), "{:?}", bounds(&s, second));
    assert!(close(bounds(&s, first), Rect::new(110.0, 50.0, 190.0, 90.0)), "{:?}", bounds(&s, first));
}

#[test]
fn the_symbols_panel_edits_a_symbol_without_an_instance_at_the_artboard_center() {
    let (mut s, first, second) = two_instances();
    run(&mut s, "edit.clear", json!({"ids": [first.0, second.0]}));
    run(&mut s, "select.none", json!({}));
    let r = run(&mut s, "symbol.edit", json!({"name": "Box"}));
    assert!(r.get("id").is_none());
    let art = layer_art(&s);
    assert!(close(bounds(&s, art[0]), Rect::new(160.0, 130.0, 240.0, 170.0)), "{:?}", bounds(&s, art[0]));
    run(&mut s, "object.move", json!({"dx": 0, "dy": 5}));
    run(&mut s, "symbol.exitEditing", json!({}));
    // No instance was added, and a new one shows the edited art.
    let mut instances = 0;
    s.doc().unwrap().doc.walk(|n| instances += usize::from(matches!(n.kind, NodeKind::SymbolInstance { .. })));
    assert_eq!(instances, 0);
    let placed = id(&run(&mut s, "symbol.place", json!({"name": "Box", "x": 200, "y": 150})));
    assert!(close(bounds(&s, placed), Rect::new(160.0, 135.0, 240.0, 175.0)), "{:?}", bounds(&s, placed));
    assert!(s.execute("symbol.edit", &json!({"name": "Nope"})).is_err());
}

#[test]
fn the_symbols_panel_edits_a_symbol_at_the_center_of_the_active_artboard_or_the_view() {
    let (mut s, _, _) = two_instances();
    run(&mut s, "artboard.new", json!({"x": 500, "y": 0, "width": 200, "height": 100}));
    run(&mut s, "select.none", json!({}));
    run(&mut s, "symbol.edit", json!({"name": "Box", "artboard": 1}));
    let art = layer_art(&s);
    assert!(close(bounds(&s, art[0]), Rect::new(560.0, 30.0, 640.0, 70.0)), "{:?}", bounds(&s, art[0]));
    run(&mut s, "symbol.exitEditing", json!({}));
    // An artboard the document doesn't have: the first one.
    run(&mut s, "symbol.edit", json!({"name": "Box", "artboard": 7, "viewCenter": [1000, 1000]}));
    let art = layer_art(&s);
    assert!(close(bounds(&s, art[0]), Rect::new(160.0, 130.0, 240.0, 170.0)), "{:?}", bounds(&s, art[0]));
    run(&mut s, "symbol.exitEditing", json!({}));
    // Without artboards, the view's center.
    std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).artboards.clear();
    run(&mut s, "symbol.edit", json!({"name": "Box", "viewCenter": [1000, 1000]}));
    let art = layer_art(&s);
    assert!(close(bounds(&s, art[0]), Rect::new(960.0, 980.0, 1040.0, 1020.0)), "{:?}", bounds(&s, art[0]));
}

#[test]
fn leaving_without_an_edit_leaves_the_document_and_its_history_as_they_were() {
    let (mut s, first, _) = two_instances();
    let steps = s.doc().unwrap().history.undo.len();
    let art = s.doc().unwrap().doc.symbols[0].art.clone();
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
    run(&mut s, "object.exitIsolation", json!({}));
    let st = s.doc().unwrap();
    assert_eq!(st.history.undo.len(), steps);
    assert!(std::sync::Arc::ptr_eq(&st.doc.symbols[0].art, &art));
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none());
    // Outside the mode, leaving it does nothing.
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(s.doc().unwrap().history.undo.len(), steps);
    // A step undone before editing can still be redone after leaving without an edit.
    run(&mut s, "shape.rectangle", json!({"x": 300, "y": 20, "width": 10, "height": 10}));
    run(&mut s, "edit.undo", json!({}));
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    assert!(s.doc().unwrap().history.redo.is_empty());
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(s.doc().unwrap().history.redo.len(), 1);
    run(&mut s, "edit.redo", json!({}));
    // Leaving after an edit that was undone adds a step, keeping the redo step that holds the
    // editing layer apart from the document outside the mode.
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    run(&mut s, "object.move", json!({"dx": 10, "dy": 0}));
    run(&mut s, "edit.undo", json!({}));
    let steps = s.doc().unwrap().history.undo.len();
    run(&mut s, "symbol.exitEditing", json!({}));
    let st = s.doc().unwrap();
    assert_eq!(st.history.undo.len(), steps + 1);
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none());
}

#[test]
fn leaving_without_an_edit_keeps_the_current_symbol_picked_while_editing() {
    let (mut s, first, _) = two_instances();
    run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20}));
    run(&mut s, "symbol.new", json!({"name": "Small"}));
    run(&mut s, "symbol.setCurrent", json!({"name": "Box"}));
    let steps = s.doc().unwrap().history.undo.len();
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    // A click in the Symbols panel while editing: not an undo step.
    run(&mut s, "symbol.setCurrent", json!({"name": "Small"}));
    run(&mut s, "symbol.exitEditing", json!({}));
    let st = s.doc().unwrap();
    assert_eq!(st.history.undo.len(), steps);
    assert_eq!(st.doc.unknown.get("currentSymbol").and_then(Value::as_str), Some("Small"));
}

#[test]
fn leaving_right_after_a_batch_that_only_entered_takes_its_step_back() {
    let (mut s, first, _) = two_instances();
    let steps = s.doc().unwrap().history.undo.len();
    run(&mut s, "command.batch", json!({"commands": [{"command": "symbol.edit", "params": {"id": first.0}}]}));
    assert!(s.doc().unwrap().doc.symbol_edit.is_some());
    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
    run(&mut s, "symbol.exitEditing", json!({}));
    let st = s.doc().unwrap();
    assert_eq!(st.history.undo.len(), steps);
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none());
}

#[test]
fn leaving_right_after_a_batch_that_edited_and_entered_keeps_its_edits() {
    let (mut s, first, second) = two_instances();
    let steps = s.doc().unwrap().history.undo.len();
    // A batch named like the entering step that moves an instance before entering: leaving keeps
    // the move and adds a step of its own.
    let moved = Rect::new(310.0, 180.0, 390.0, 220.0);
    let commands = json!([
        {"command": "select.set", "params": {"ids": [second.0]}},
        {"command": "object.move", "params": {"dx": 50, "dy": 0}},
        {"command": "symbol.edit", "params": {"id": first.0}},
    ]);
    run(&mut s, "command.batch", json!({"label": "Edit Symbol", "commands": commands}));
    assert!(close(bounds(&s, second), moved), "{:?}", bounds(&s, second));
    run(&mut s, "symbol.exitEditing", json!({}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none());
    assert_eq!(st.history.undo.len(), steps + 2);
    assert!(close(bounds(&s, second), moved), "{:?}", bounds(&s, second));
    // Undo takes back the exit, then the batch's move and entry together.
    run(&mut s, "edit.undo", json!({}));
    assert!(s.doc().unwrap().doc.symbol_edit.is_some());
    run(&mut s, "edit.undo", json!({}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none());
    assert!(close(bounds(&s, second), Rect::new(260.0, 180.0, 340.0, 220.0)), "{:?}", bounds(&s, second));
}

#[test]
fn redefining_the_symbol_being_edited_leaves_symbol_editing_mode_in_the_same_step() {
    let (mut s, first, second) = two_instances();
    let other = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 200, "width": 30, "height": 30})));
    let layer = NodeId(run(&mut s, "symbol.edit", json!({"id": first.0}))["layer"].as_u64().unwrap());
    // The art on the editing layer can't redefine the symbol.
    let e = s.execute("symbol.update", &json!({"name": "Box"})).unwrap_err().to_string();
    assert!(e.contains("can't hold an instance of itself"), "{e}");
    let steps = s.doc().unwrap().history.undo.len();
    run(&mut s, "symbol.update", json!({"name": "Box", "ids": [other.0]}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none() && st.doc.node(layer).is_none());
    assert_eq!(st.history.undo.len(), steps + 1);
    // Every instance shows the new 30 × 30 art, and a later edit can't bring the old art back.
    assert!(close(bounds(&s, second), Rect::new(285.0, 185.0, 315.0, 215.0)), "{:?}", bounds(&s, second));
    run(&mut s, "shape.rectangle", json!({"x": 300, "y": 10, "width": 10, "height": 10}));
    assert!(close(bounds(&s, second), Rect::new(285.0, 185.0, 315.0, 215.0)), "{:?}", bounds(&s, second));
    // Undo goes back into the edit as it was.
    run(&mut s, "edit.undo", json!({}));
    run(&mut s, "edit.undo", json!({}));
    let st = s.doc().unwrap();
    assert_eq!(st.isolation, Some(layer));
    assert!(st.doc.symbol_edit.is_some());
}

/// Redefining the symbol being edited with `keepArt: true` also leaves symbol editing mode in the
/// same step; the art outside the editing layer stays ordinary art and stays selected, and the
/// art on the editing layer still can't redefine it.
#[test]
fn redefining_the_symbol_being_edited_with_keep_art_leaves_the_art_and_the_mode() {
    let (mut s, first, second) = two_instances();
    let other = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 200, "width": 30, "height": 30})));
    let layer = NodeId(run(&mut s, "symbol.edit", json!({"id": first.0}))["layer"].as_u64().unwrap());
    let e = s.execute("symbol.update", &json!({"name": "Box", "keepArt": true})).unwrap_err().to_string();
    assert!(e.contains("can't hold an instance of itself"), "{e}");
    let steps = s.doc().unwrap().history.undo.len();
    let r = run(&mut s, "symbol.update", json!({"name": "Box", "ids": [other.0], "keepArt": true}));
    assert!(r["id"].is_null(), "{r}");
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none() && st.doc.node(layer).is_none());
    assert_eq!(st.history.undo.len(), steps + 1);
    assert!(matches!(st.doc.node(other).map(|n| &n.kind), Some(NodeKind::Path { .. })), "the art stays ordinary art");
    assert_eq!(st.selection.objects, vec![other], "the art stays selected");
    assert!(is_instance(&s, first), "the instance editing was entered from is still an instance");
    assert!(close(bounds(&s, second), Rect::new(285.0, 185.0, 315.0, 215.0)), "{:?}", bounds(&s, second));
}

#[test]
fn leaving_goes_back_to_the_isolation_before_and_undo_keeps_a_group_isolated_inside() {
    let (mut s, first, _) = two_instances();
    // The instance in an isolated group.
    let other = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 200, "width": 20, "height": 20})));
    run(&mut s, "select.set", json!({"ids": [first.0, other.0]}));
    let group = id(&run(&mut s, "object.group", json!({})));
    run(&mut s, "object.isolate", json!({"id": group.0}));
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(s.doc().unwrap().isolation, Some(group));
    // A group isolated inside the symbol's art stays isolated through an undo.
    let layer = NodeId(run(&mut s, "symbol.edit", json!({"id": first.0}))["layer"].as_u64().unwrap());
    run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 10, "height": 10}));
    let art: Vec<u64> = layer_art(&s).iter().map(|i| i.0).collect();
    run(&mut s, "select.set", json!({ "ids": art }));
    let inner = id(&run(&mut s, "object.group", json!({})));
    run(&mut s, "object.isolate", json!({"id": inner.0}));
    run(&mut s, "select.all", json!({}));
    run(&mut s, "object.move", json!({"dx": 5, "dy": 0}));
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc().unwrap().isolation, Some(inner));
    run(&mut s, "object.exitIsolation", json!({}));
    assert_eq!(s.doc().unwrap().isolation, Some(layer));
    run(&mut s, "object.exitIsolation", json!({}));
    assert_eq!(s.doc().unwrap().isolation, Some(group));
    // Deleting the editing layer goes back there too.
    let layer = NodeId(run(&mut s, "symbol.edit", json!({"id": first.0}))["layer"].as_u64().unwrap());
    run(&mut s, "layer.delete", json!({"ids": [layer.0]}));
    assert_eq!(s.doc().unwrap().isolation, Some(group));
}

#[test]
fn leaving_after_a_save_keeps_the_document_saved() {
    let (mut s, first, _) = two_instances();
    for edit in [false, true] {
        run(&mut s, "symbol.edit", json!({"id": first.0}));
        if edit {
            run(&mut s, "object.move", json!({"dx": 10, "dy": 0}));
        }
        // The save leaves the editing layer out of the file.
        s.doc_mut().unwrap().mark_saved();
        run(&mut s, "symbol.exitEditing", json!({}));
        let st = s.doc().unwrap();
        assert!(!st.is_dirty(), "edit: {edit}");
        assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none(), "edit: {edit}");
    }
}

#[test]
fn deleting_the_editing_layer_leaves_symbol_editing_mode() {
    let (mut s, first, _) = two_instances();
    let layer = NodeId(run(&mut s, "symbol.edit", json!({"id": first.0}))["layer"].as_u64().unwrap());
    run(&mut s, "layer.delete", json!({"ids": [layer.0]}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.doc.node(layer).is_none());
    assert_eq!(st.isolation, None);
    assert!(st.active_layer.is_some_and(|l| st.doc.node(l).is_some()));
    assert!(is_instance(&s, first));
}

#[test]
fn undo_and_redo_restore_the_art_every_instance_shows_and_the_mode() {
    let (mut s, first, second) = two_instances();
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    let layer = s.doc().unwrap().doc.symbol_edit.as_ref().unwrap().layer;
    run(&mut s, "object.move", json!({"dx": 10, "dy": 0}));
    run(&mut s, "symbol.exitEditing", json!({}));
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc().unwrap().isolation, Some(layer), "back in symbol editing mode");
    run(&mut s, "edit.undo", json!({}));
    assert!(close(bounds(&s, second), Rect::new(260.0, 180.0, 340.0, 220.0)), "{:?}", bounds(&s, second));
    assert_eq!(s.doc().unwrap().isolation, Some(layer));
    run(&mut s, "edit.undo", json!({}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none());
    run(&mut s, "edit.redo", json!({}));
    run(&mut s, "edit.redo", json!({}));
    assert!(close(bounds(&s, second), Rect::new(270.0, 180.0, 350.0, 220.0)), "{:?}", bounds(&s, second));
    assert_eq!(s.doc().unwrap().isolation, Some(layer));
}

#[test]
fn instances_of_one_symbol_only_and_no_instance_of_itself() {
    let (mut s, first, _) = two_instances();
    run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20}));
    let other = id(&run(&mut s, "symbol.new", json!({"name": "Small"})));
    run(&mut s, "select.set", json!({"ids": [first.0, other.0]}));
    let e = s.execute("symbol.edit", &json!({})).unwrap_err().to_string();
    assert!(e.contains("select instances of one symbol"), "{e}");
    let e = s.execute("symbol.edit", &json!({"ids": [first.0, other.0]})).unwrap_err().to_string();
    assert!(e.contains("select instances of one symbol"), "{e}");
    assert!(s.execute("symbol.edit", &json!({"ids": [first.0, 999_999]})).is_err());
    assert!(s.doc().unwrap().doc.symbol_edit.is_none());
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    let e = s.execute("symbol.place", &json!({"name": "Box"})).unwrap_err().to_string();
    assert!(e.contains("can't hold an instance of itself"), "{e}");
    assert_eq!(layer_art(&s).len(), 1);
    // An instance of another symbol may go in.
    run(&mut s, "symbol.place", json!({"name": "Small"}));
    assert_eq!(layer_art(&s).len(), 2);
}

#[test]
fn other_editing_modes_and_symbol_editing_do_not_overlap() {
    let (mut s, first, second) = two_instances();
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    assert!(s.execute("object.pattern.make", &json!({})).is_err());
    assert!(s.execute("transparency.editOpacityMask", &json!({})).is_err());
    // Editing another symbol from the panel ends this edit first.
    run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20}));
    run(&mut s, "symbol.exitEditing", json!({}));
    run(&mut s, "select.set", json!({"ids": [second.0]}));
    run(&mut s, "symbol.edit", json!({}));
    run(&mut s, "symbol.edit", json!({"name": "Box", "x": 50, "y": 50}));
    assert_eq!(s.doc().unwrap().doc.symbol_edit.as_ref().unwrap().instance, None);
    assert_eq!(s.doc().unwrap().doc.layers.iter().filter(|l| l.name.as_deref() == Some("Box")).count(), 1);
}

/// Editing another symbol at a place off the canvas fails and keeps the current edit open.
#[test]
fn a_switch_to_another_symbol_that_fails_keeps_the_current_edit() {
    let (mut s, first, _) = two_instances();
    run(&mut s, "shape.rectangle", json!({"x": 10, "y": 200, "width": 20, "height": 20}));
    run(&mut s, "symbol.new", json!({"name": "Dot"}));
    let layer = NodeId(run(&mut s, "symbol.edit", json!({"id": first.0}))["layer"].as_u64().unwrap());
    let e = s.execute("symbol.edit", &json!({"name": "Dot", "x": 1e300})).unwrap_err().to_string();
    assert!(e.contains("exceed the canvas"), "{e}");
    let st = s.doc().unwrap();
    assert_eq!(st.doc.symbol_edit.as_ref().map(|e| (e.symbol.as_str(), e.layer)), Some(("Box", layer)));
    assert_eq!((st.isolation, st.active_layer), (Some(layer), Some(layer)));
    assert!(st.doc.node(layer).is_some());
}

/// While a symbol is edited, art outside the editing layer is not isolated, so leaving isolation
/// mode leaves symbol editing mode.
#[test]
fn art_outside_the_editing_layer_is_not_isolated_while_a_symbol_is_edited() {
    let (mut s, first, _) = two_instances();
    let other = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 200, "width": 20, "height": 20})));
    run(&mut s, "select.set", json!({"ids": [first.0]}));
    let layer = NodeId(run(&mut s, "symbol.edit", json!({"id": first.0}))["layer"].as_u64().unwrap());
    let e = s.execute("object.isolate", &json!({"id": other.0})).unwrap_err().to_string();
    assert!(e.contains("outside the isolated group"), "{e}");
    assert_eq!(s.doc().unwrap().isolation, Some(layer));
    // Isolation that names art outside the layer (a stale state) still leaves the mode.
    s.doc_mut().unwrap().isolation = Some(other);
    run(&mut s, "object.exitIsolation", json!({}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.doc.node(layer).is_none());
    assert_eq!(st.isolation, None);
    assert_eq!(st.selection.objects, vec![first]);
}

#[test]
fn renaming_deleting_and_saving_while_a_symbol_is_edited() {
    let (mut s, first, _) = two_instances();
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    run(&mut s, "object.move", json!({"dx": 10, "dy": 0}));
    let layer = s.doc().unwrap().doc.symbol_edit.as_ref().unwrap().layer;
    // Saving leaves the editing layer out; the symbol already holds the edit.
    let saved = s.doc().unwrap().doc.without_edit_modes().into_owned();
    assert!(saved.symbol_edit.is_none() && saved.node(layer).is_none());
    assert!(saved.symbols[0].art.geometric_bounds().is_some());
    run(&mut s, "symbol.options", json!({"name": "Box", "newName": "Crate"}));
    let st = s.doc().unwrap();
    assert_eq!(st.doc.symbol_edit.as_ref().unwrap().symbol, "Crate");
    assert_eq!(st.doc.node(layer).and_then(|l| l.name.clone()).as_deref(), Some("Crate"));
    run(&mut s, "object.move", json!({"dx": 10, "dy": 0}));
    // Deleting the symbol being edited leaves the mode in the same step.
    run(&mut s, "symbol.delete", json!({"name": "Crate"}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none() && st.doc.node(layer).is_none());
    assert!(st.doc.symbols.is_empty());
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc().unwrap().isolation, Some(layer));
}

/// Deleting several symbols, the one being edited among them, leaves the mode in the same step.
#[test]
fn deleting_several_symbols_with_the_edited_one_leaves_the_mode() {
    let (mut s, first, _) = two_instances();
    run(&mut s, "shape.rectangle", json!({"x": 10, "y": 200, "width": 20, "height": 20}));
    run(&mut s, "symbol.new", json!({"name": "Dot"}));
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    let layer = s.doc().unwrap().doc.symbol_edit.as_ref().unwrap().layer;
    run(&mut s, "symbol.delete", json!({"names": ["Dot", "Box"]}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.isolation.is_none() && st.doc.node(layer).is_none());
    assert!(st.doc.symbols.is_empty());
}

/// Editing a dynamic symbol keeps each instance's appearance changes to the objects its art still
/// has, and drops the changes to an object the edit deleted.
#[test]
fn editing_a_dynamic_symbol_keeps_the_instances_changes_to_the_objects_still_there() {
    let mut s = Session::new();
    run(&mut s, "file.new", json!({"width": 400, "height": 300}));
    let a = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 40, "height": 40})));
    let b = id(&run(&mut s, "shape.rectangle", json!({"x": 60, "y": 10, "width": 40, "height": 40})));
    let inst = id(&run(&mut s, "symbol.new", json!({"name": "Pair", "ids": [a.0, b.0], "type": "dynamic"})));
    run(&mut s, "symbol.instance.setAppearance", json!({"id": inst.0, "path": [0], "fill": "#00ff00"}));
    run(&mut s, "symbol.instance.setAppearance", json!({"id": inst.0, "path": [1], "fill": "#ff0000"}));
    // Each change by the path it names and the color it paints.
    let changes = |s: &Session| -> Vec<(Vec<u32>, String)> {
        let n = s.doc().unwrap().doc.node(inst).unwrap().clone();
        n.extras().symbol_overrides.iter().map(|o| (o.path.clone(), o.fill.as_ref().and_then(|p| p.color()).unwrap().to_hex())).collect()
    };
    let other = id(&run(&mut s, "symbol.place", json!({"name": "Pair", "x": 200, "y": 200})));
    run(&mut s, "symbol.edit", json!({"id": other.0}));
    let art = layer_art(&s);
    assert_eq!(art.len(), 2);
    // Deleting the first object: the change to the second follows it to the first place.
    run(&mut s, "select.set", json!({"ids": [art[0].0]}));
    run(&mut s, "edit.clear", json!({}));
    assert_eq!(changes(&s), vec![(vec![0], "#ff0000".to_string())], "the change to the deleted object goes");
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(changes(&s), vec![(vec![0], "#ff0000".to_string())]);
    assert!(s.doc().unwrap().doc.node(inst).is_some_and(|n| matches!(n.kind, NodeKind::SymbolInstance { .. })));
}

/// An instance of the edited dynamic symbol inside another symbol's art keeps its appearance
/// changes on the same objects when the edit reorders them, and drops the change to an object the
/// edit deleted.
#[test]
fn an_instance_inside_another_symbols_art_follows_an_edit_of_its_dynamic_symbol() {
    let mut s = Session::new();
    run(&mut s, "file.new", json!({"width": 400, "height": 300}));
    let a = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 40, "height": 40})));
    let b = id(&run(&mut s, "shape.rectangle", json!({"x": 60, "y": 10, "width": 40, "height": 40})));
    let inst = id(&run(&mut s, "symbol.new", json!({"name": "Pair", "ids": [a.0, b.0], "type": "dynamic"})));
    run(&mut s, "symbol.instance.setAppearance", json!({"id": inst.0, "path": [0], "fill": "#00ff00"}));
    run(&mut s, "symbol.instance.setAppearance", json!({"id": inst.0, "path": [1], "fill": "#ff0000"}));
    run(&mut s, "symbol.new", json!({"name": "Outer", "ids": [inst.0]}));
    // The changes of the instance of "Pair" in the art of "Outer", by path and color.
    let nested = |s: &Session| -> Vec<(Vec<u32>, String)> {
        let d = &s.doc().unwrap().doc;
        let outer = d.symbols.iter().find(|x| x.name == "Outer").expect("Outer");
        let mut out = vec![];
        outer.art.walk(&mut |n| {
            if matches!(&n.kind, NodeKind::SymbolInstance { symbol, .. } if symbol == "Pair") {
                out.extend(n.extras().symbol_overrides.iter().map(|o| (o.path.clone(), o.fill.as_ref().and_then(|p| p.color()).unwrap().to_hex())));
            }
        });
        out
    };
    let start = vec![(vec![0], "#00ff00".to_string()), (vec![1], "#ff0000".to_string())];
    assert_eq!(nested(&s), start);
    let other = id(&run(&mut s, "symbol.place", json!({"name": "Pair", "x": 200, "y": 200})));
    run(&mut s, "symbol.edit", json!({"id": other.0}));
    let art = layer_art(&s);
    assert_eq!(art.len(), 2);
    // Sending the second object to the back: each change follows its object.
    run(&mut s, "select.set", json!({"ids": [art[1].0]}));
    run(&mut s, "object.arrange.sendToBack", json!({}));
    assert_eq!(layer_art(&s), vec![art[1], art[0]]);
    assert_eq!(nested(&s), vec![(vec![1], "#00ff00".to_string()), (vec![0], "#ff0000".to_string())]);
    // Deleting the first object: the change to it goes.
    run(&mut s, "select.set", json!({"ids": [art[0].0]}));
    run(&mut s, "edit.clear", json!({}));
    assert_eq!(nested(&s), vec![(vec![0], "#ff0000".to_string())]);
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(nested(&s), vec![(vec![0], "#ff0000".to_string())]);
}

/// Instances of the edited dynamic symbol in a pattern tile, a graph design and an art brush keep
/// their appearance changes on the same objects when the edit reorders them, and drop the change
/// to an object the edit deleted.
#[test]
fn instances_in_pattern_tiles_graph_designs_and_brushes_follow_an_edit_of_their_dynamic_symbol() {
    let mut s = Session::new();
    run(&mut s, "file.new", json!({"width": 400, "height": 300}));
    let a = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 40, "height": 40})));
    let b = id(&run(&mut s, "shape.rectangle", json!({"x": 60, "y": 10, "width": 40, "height": 40})));
    let inst = id(&run(&mut s, "symbol.new", json!({"name": "Pair", "ids": [a.0, b.0], "type": "dynamic"})));
    run(&mut s, "symbol.instance.setAppearance", json!({"id": inst.0, "path": [0], "fill": "#00ff00"}));
    run(&mut s, "symbol.instance.setAppearance", json!({"id": inst.0, "path": [1], "fill": "#ff0000"}));
    run(&mut s, "object.pattern.make", json!({"ids": [inst.0], "name": "Tile", "edit": false}));
    run(&mut s, "select.set", json!({"ids": [inst.0]}));
    run(&mut s, "graph.design", json!({"new": "Pairs"}));
    run(&mut s, "brush.new", json!({"type": "art", "name": "Pair Band", "ids": [inst.0]}));
    // A stored entry that does not parse, and a field the brush definition does not read, are kept.
    let junk = json!({"name": "Unreadable", "kind": 7});
    let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
    let Some(Value::Array(entries)) = doc.unknown.get_mut(vectorcraft_brush::DOC_KEY) else { panic!("no stored brushes") };
    entries.iter_mut().filter(|e| e["name"] == "Pair Band").for_each(|e| e["note"] = json!("kept"));
    entries.push(junk.clone());
    // The changes of each instance of "Pair" in `n`, by path and color.
    fn changes(n: &Node, out: &mut Vec<(Vec<u32>, String)>) {
        n.walk(&mut |n| {
            if matches!(&n.kind, NodeKind::SymbolInstance { symbol, .. } if symbol == "Pair") {
                out.extend(n.extras().symbol_overrides.iter().map(|o| (o.path.clone(), o.fill.as_ref().and_then(|p| p.color()).unwrap().to_hex())));
            }
        });
    }
    // The changes in the tile, the graph design and the brush.
    let held = |s: &Session| -> [Vec<(Vec<u32>, String)>; 3] {
        let d = &s.doc().unwrap().doc;
        let mut out: [Vec<(Vec<u32>, String)>; 3] = Default::default();
        d.patterns.iter().filter(|p| p.name == "Tile").flat_map(|p| &p.art).for_each(|n| changes(n, &mut out[0]));
        d.graph_designs.iter().for_each(|g| changes(&g.art, &mut out[1]));
        let brush = vectorcraft_brush::find(d, "Pair Band").expect("the brush");
        brush.art().into_iter().for_each(|n| changes(n, &mut out[2]));
        out
    };
    let start = vec![(vec![0], "#00ff00".to_string()), (vec![1], "#ff0000".to_string())];
    assert_eq!(held(&s), [start.clone(), start.clone(), start]);
    let other = id(&run(&mut s, "symbol.place", json!({"name": "Pair", "x": 200, "y": 200})));
    run(&mut s, "symbol.edit", json!({"id": other.0}));
    let art = layer_art(&s);
    assert_eq!(art.len(), 2);
    // Sending the second object to the back: each change follows its object.
    run(&mut s, "select.set", json!({"ids": [art[1].0]}));
    run(&mut s, "object.arrange.sendToBack", json!({}));
    let swapped = vec![(vec![1], "#00ff00".to_string()), (vec![0], "#ff0000".to_string())];
    assert_eq!(held(&s), [swapped.clone(), swapped.clone(), swapped]);
    // Deleting the first object: the change to it goes.
    run(&mut s, "select.set", json!({"ids": [art[0].0]}));
    run(&mut s, "edit.clear", json!({}));
    let left = vec![(vec![0], "#ff0000".to_string())];
    assert_eq!(held(&s), [left.clone(), left.clone(), left.clone()]);
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(held(&s), [left.clone(), left.clone(), left]);
    let stored = &s.doc().unwrap().doc.unknown[vectorcraft_brush::DOC_KEY];
    assert!(stored.as_array().is_some_and(|a| a.contains(&junk)), "{stored}");
    assert!(stored.as_array().is_some_and(|a| a.iter().any(|e| e["name"] == "Pair Band" && e["note"] == "kept")), "{stored}");
}

/// An instance of a dynamic symbol that is the opacity mask of an object on a layer keeps its
/// appearance changes on the same objects when the edit reorders them, and drops the change to an
/// object the edit deleted.
#[test]
fn an_instance_in_an_opacity_mask_follows_an_edit_of_its_dynamic_symbol() {
    let mut s = Session::new();
    run(&mut s, "file.new", json!({"width": 400, "height": 300}));
    let a = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 40, "height": 40})));
    let b = id(&run(&mut s, "shape.rectangle", json!({"x": 60, "y": 10, "width": 40, "height": 40})));
    let inst = id(&run(&mut s, "symbol.new", json!({"name": "Pair", "ids": [a.0, b.0], "type": "dynamic"})));
    run(&mut s, "symbol.instance.setAppearance", json!({"id": inst.0, "path": [0], "fill": "#00ff00"}));
    run(&mut s, "symbol.instance.setAppearance", json!({"id": inst.0, "path": [1], "fill": "#ff0000"}));
    let masked = id(&run(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 120, "height": 60})));
    run(&mut s, "select.set", json!({"ids": [inst.0]}));
    run(&mut s, "object.arrange.bringToFront", json!({}));
    run(&mut s, "transparency.makeOpacityMask", json!({"ids": [masked.0, inst.0]}));
    // The changes of the instance of "Pair" in the masked object's mask, by path and color.
    let held = |s: &Session| -> Vec<(Vec<u32>, String)> {
        let d = &s.doc().unwrap().doc;
        let mask = d.node(masked).and_then(|n| n.extras().mask.clone()).expect("the opacity mask");
        let mut out = vec![];
        vectorcraft_doc::swatches::walk_with_masks(&mask.art, &mut |n| {
            if matches!(&n.kind, NodeKind::SymbolInstance { symbol, .. } if symbol == "Pair") {
                out.extend(n.extras().symbol_overrides.iter().map(|o| (o.path.clone(), o.fill.as_ref().and_then(|p| p.color()).unwrap().to_hex())));
            }
        });
        out
    };
    assert_eq!(held(&s), vec![(vec![0], "#00ff00".to_string()), (vec![1], "#ff0000".to_string())]);
    let other = id(&run(&mut s, "symbol.place", json!({"name": "Pair", "x": 200, "y": 200})));
    run(&mut s, "symbol.edit", json!({"id": other.0}));
    let art = layer_art(&s);
    assert_eq!(art.len(), 2);
    // Sending the second object to the back: each change follows its object.
    run(&mut s, "select.set", json!({"ids": [art[1].0]}));
    run(&mut s, "object.arrange.sendToBack", json!({}));
    assert_eq!(held(&s), vec![(vec![1], "#00ff00".to_string()), (vec![0], "#ff0000".to_string())]);
    // Deleting the first object: the change to it goes.
    run(&mut s, "select.set", json!({"ids": [art[0].0]}));
    run(&mut s, "edit.clear", json!({}));
    assert_eq!(held(&s), vec![(vec![0], "#ff0000".to_string())]);
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(held(&s), vec![(vec![0], "#ff0000".to_string())]);
}

#[test]
fn undo_back_into_an_earlier_edit_leaves_it_to_its_own_isolation() {
    let (mut s, first, second) = two_instances();
    let other = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 200, "width": 20, "height": 20})));
    run(&mut s, "select.set", json!({"ids": [second.0, other.0]}));
    let group = id(&run(&mut s, "object.group", json!({})));
    // The first edit is entered with nothing isolated.
    run(&mut s, "symbol.edit", json!({"id": first.0}));
    run(&mut s, "object.move", json!({"dx": 10, "dy": 0}));
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(s.doc().unwrap().isolation, None);
    // The second edit is entered with the group isolated.
    run(&mut s, "object.isolate", json!({"id": group.0}));
    run(&mut s, "symbol.edit", json!({"id": second.0}));
    run(&mut s, "edit.undo", json!({}));
    assert_eq!(s.doc().unwrap().isolation, Some(group));
    // Back in the first edit, leaving it goes back to what it was entered from.
    run(&mut s, "edit.undo", json!({}));
    assert!(s.doc().unwrap().doc.symbol_edit.is_some());
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(s.doc().unwrap().isolation, None);
}

#[test]
fn undoing_entry_with_a_group_isolated_inside_the_art_goes_back_to_before() {
    let mut s = Session::new();
    run(&mut s, "file.new", json!({"width": 400, "height": 300}));
    let a = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})));
    let b = id(&run(&mut s, "shape.rectangle", json!({"x": 40, "y": 10, "width": 20, "height": 20})));
    run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
    let inner = id(&run(&mut s, "object.group", json!({})));
    let c = id(&run(&mut s, "shape.rectangle", json!({"x": 10, "y": 40, "width": 20, "height": 20})));
    run(&mut s, "select.set", json!({"ids": [inner.0, c.0]}));
    let instance = id(&run(&mut s, "symbol.new", json!({"name": "Pair"})));
    let before = s.doc().unwrap().active_layer;
    assert!(before.is_some());
    run(&mut s, "symbol.edit", json!({"id": instance.0}));
    let layer = s.doc().unwrap().doc.symbol_edit.as_ref().unwrap().layer;
    let group = {
        let st = s.doc().unwrap();
        layer_art(&s).into_iter().find(|i| st.doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Group { .. }))).expect("a group")
    };
    run(&mut s, "object.isolate", json!({"id": group.0}));
    assert_eq!(s.doc().unwrap().isolation, Some(group));
    run(&mut s, "edit.undo", json!({}));
    let st = s.doc().unwrap();
    assert!(st.doc.symbol_edit.is_none() && st.doc.node(layer).is_none());
    assert_eq!(st.isolation, None);
    assert_eq!(st.active_layer, before);
}

/// The text wrap of the area type in `n`.
fn wrap_in(n: &Node) -> Vec<vectorcraft_doc::WrapShape> {
    let mut wrap = None;
    n.walk(&mut |n| {
        if let NodeKind::Text(t) = &n.kind {
            wrap = Some(t.wrap.clone());
        }
    });
    wrap.expect("area type")
}

#[test]
fn moving_a_wrap_object_in_the_edit_gives_the_symbol_the_new_text_wrap() {
    let mut s = Session::new();
    run(&mut s, "file.new", json!({"width": 600, "height": 600}));
    let text = "word ".repeat(200);
    let t = id(&run(&mut s, "text.create", json!({"x": 0, "y": 0, "text": text, "size": 12, "area": {"width": 400, "height": 400}})));
    let r = id(&run(&mut s, "shape.rectangle", json!({"x": 0, "y": 50, "width": 200, "height": 100})));
    run(&mut s, "select.set", json!({"ids": [r.0]}));
    run(&mut s, "object.textWrap.make", json!({}));
    run(&mut s, "select.set", json!({"ids": [t.0, r.0]}));
    let instance = id(&run(&mut s, "symbol.new", json!({"name": "Wrapped"})));
    let symbol_wrap = |s: &Session| wrap_in(&s.doc().unwrap().doc.symbols.iter().find(|x| x.name == "Wrapped").expect("the symbol").art);
    let entered = symbol_wrap(&s);
    assert!(!entered.is_empty());
    run(&mut s, "symbol.edit", json!({"id": instance.0}));
    let (layer, rect) = {
        let st = s.doc().unwrap();
        let layer = st.doc.symbol_edit.as_ref().unwrap().layer;
        let rect = layer_art(&s).into_iter().find(|i| st.doc.node(*i).is_some_and(|n| n.extras().wrap.is_some())).expect("the wrap object");
        (layer, rect)
    };
    run(&mut s, "select.set", json!({"ids": [rect.0]}));
    run(&mut s, "object.move", json!({"dx": 150, "dy": 0}));
    let on_layer = wrap_in(s.doc().unwrap().doc.node(layer).unwrap());
    assert_ne!(on_layer, entered, "the editing layer's text wraps around the moved object");
    assert_eq!(symbol_wrap(&s), on_layer);
    // Leaving keeps it.
    run(&mut s, "symbol.exitEditing", json!({}));
    assert_eq!(symbol_wrap(&s), on_layer);
}