Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

10.1 KB
Raw Blame
use super::*;
use crate::edit::{History, Op};
use crate::model::PaintKind;
use crate::scene::Scene;
use crate::testing::{V, fig_file, node, simple_file, size, solid, translate};

fn apply(doc: &mut Document, json: &str) -> Vec<String> {
    let ops: Vec<Op> = serde_json::from_str(json).unwrap();
    History::default().apply(doc, &ops, None).unwrap().created
}

fn find<'a>(doc: &'a Document, id: &str) -> &'a crate::model::Props {
    doc.props(doc.find(Guid::parse(id).unwrap()).unwrap())
}

#[test]
fn saves_edits_and_reopens() {
    let original = simple_file();
    let mut doc = Document::open(&original).unwrap();
    let created = apply(
        &mut doc,
        r#"[{"op":"set","ids":["1:3"],"props":{"name":"Moved","x":40,"y":50,"fills":[{"color":"00FF00"}]}},
            {"op":"create","parent":"1:2","node":{"type":"ELLIPSE","name":"Dot","x":150,"y":150,"width":20,"height":20}}]"#,
    );
    let saved = save(&doc, &original).unwrap();
    let reopened = Document::open(&saved).unwrap();
    let rect = find(&reopened, "1:3");
    assert_eq!(rect.name(), "Moved");
    assert_eq!(rect.transform().m02, 40.0);
    assert_eq!(rect.transform().m12, 50.0);
    assert!(matches!(rect.fills()[0].kind, PaintKind::Solid(c) if c.g == 1.0 && c.r == 0.0));
    let dot = find(&reopened, &created[0]);
    assert_eq!(dot.name(), "Dot");
    assert_eq!(dot.node_type(), NodeType::Ellipse);
    let frame = reopened.find(Guid::parse("1:2").unwrap()).unwrap();
    assert_eq!(reopened.node(frame).children.len(), 2);
    // The saved file has a thumbnail and draws the same.
    assert!(
        reopened
            .thumbnail
            .as_deref()
            .is_some_and(|t| t.starts_with(b"\x89PNG"))
    );
    let scene = Scene::build(&reopened, reopened.pages[0]);
    assert_eq!(scene.nodes.len(), 4);
}

#[test]
fn saves_arc_metadata_for_new_ellipses() {
    let original = blank("Arc");
    let mut doc = Document::open(&original).unwrap();
    let created = apply(
        &mut doc,
        r#"[{"op":"create","parent":"0:1","node":{"type":"ELLIPSE","name":"Arc","x":0,"y":0,"width":40,"height":40}}]"#,
    );
    let id = doc.find(Guid::parse(&created[0]).unwrap()).unwrap();
    let arc = [0.25, 4.5, 1.0];
    doc.nodes[id as usize].props.arc_data = Some(arc);
    let reopened = Document::open(&save(&doc, &original).unwrap()).unwrap();
    let props = find(&reopened, &created[0]);
    assert_eq!(props.arc_data, Some(arc));
    assert!(!props.supports_shadow_spread());
}

#[test]
fn drops_deleted_nodes() {
    let original = simple_file();
    let mut doc = Document::open(&original).unwrap();
    apply(&mut doc, r#"[{"op":"delete","ids":["1:3"]}]"#);
    let reopened = Document::open(&save(&doc, &original).unwrap()).unwrap();
    assert!(reopened.find(Guid::parse("1:3").unwrap()).is_none());
    assert!(reopened.find(Guid::parse("1:2").unwrap()).is_some());
}

#[test]
fn keeps_fields_it_does_not_model() {
    let original = fig_file(
        vec![
            node(0, None, "DOCUMENT", "Document", vec![]),
            node(1, Some((0, "!")), "CANVAS", "Page", vec![]),
            node(
                2,
                Some((1, "!")),
                "RECTANGLE",
                "R",
                vec![
                    ("size", size(10.0, 10.0)),
                    ("transform", translate(0.0, 0.0)),
                    ("fillPaints", V::List(vec![solid(1.0, 0.0, 0.0)])),
                    ("unusedField", V::Str("keep me".into())),
                ],
            ),
        ],
        vec![],
    );
    let mut doc = Document::open(&original).unwrap();
    let copies = apply(
        &mut doc,
        r#"[{"op":"translate","ids":["1:2"],"dx":5,"dy":5},{"op":"duplicate","ids":["1:2"],"dx":20}]"#,
    );
    let saved = save(&doc, &original).unwrap();
    let container = Container::open(&saved).unwrap();
    let schema = Schema::decode(&container.schema).unwrap();
    let message = Decoder::new(&schema)
        .decode(
            &mut Reader::new(&container.message),
            schema.def_index("Message").unwrap(),
        )
        .unwrap();
    let Some(Value::List(changes)) = message.get(&schema, "nodeChanges") else {
        panic!("node changes");
    };
    let kept: Vec<_> = changes
        .iter()
        .filter_map(|v| match v {
            Value::Msg(m) => m.get(&schema, "unusedField"),
            _ => None,
        })
        .collect();
    assert_eq!(kept.len(), 2, "the edited node and its copy keep the field");
    let reopened = Document::open(&saved).unwrap();
    assert_eq!(find(&reopened, &copies[0]).transform().m02, 25.0);
}

#[test]
fn makes_blank_designs() {
    let bytes = blank("Untitled design");
    let mut doc = Document::open(&bytes).unwrap();
    assert_eq!(doc.file_name.as_deref(), Some("Untitled design"));
    assert_eq!(doc.pages.len(), 1);
    assert_eq!(doc.props(doc.pages[0]).name(), "Page 1");
    let created = apply(
        &mut doc,
        r#"[{"op":"create","parent":"0:1","node":{"type":"FRAME","name":"Desktop","x":0,"y":0,"width":1440,"height":1024}},
            {"op":"create","parent":"0:1","node":{"type":"TEXT","x":100,"y":100,"width":1,"height":1,"props":{"characters":"Hi Macro","fontSize":32}}}]"#,
    );
    let reopened = Document::open(&save(&doc, &bytes).unwrap()).unwrap();
    let frame = find(&reopened, &created[0]);
    assert_eq!(frame.node_type(), NodeType::Frame);
    assert_eq!(frame.size(), Vec2::new(1440.0, 1024.0));
    let text = find(&reopened, &created[1]);
    assert_eq!(
        text.text_content.as_ref().map(|c| c.characters.as_ref()),
        Some("Hi Macro")
    );
    let layout = text.text_layout.as_ref().unwrap();
    assert_eq!(layout.glyphs.len(), 8);
    let glyph_blob = layout.glyphs[0].blob.unwrap();
    assert!(
        reopened.blobs.path(glyph_blob).is_some(),
        "glyph outlines saved"
    );
    assert_eq!(
        text.text_style.as_ref().unwrap().font_family.as_deref(),
        Some("Inter")
    );
}

#[test]
fn saves_unedited_files_unchanged_in_content() {
    let original = crate::testing::showcase_file();
    let doc = Document::open(&original).unwrap();
    let reopened = Document::open(&save(&doc, &original).unwrap()).unwrap();
    assert_eq!(reopened.nodes.len(), doc.nodes.len());
    for (a, b) in doc.nodes.iter().zip(&reopened.nodes) {
        assert_eq!(a.props.guid, b.props.guid);
        assert_eq!(a.props.name, b.props.name);
        assert_eq!(a.props.transform, b.props.transform);
        assert_eq!(a.props.fills, b.props.fills);
    }
}

#[test]
fn saves_added_images() {
    let original = simple_file();
    let mut doc = Document::open(&original).unwrap();
    let mut pixmap = tiny_skia::Pixmap::new(4, 2).unwrap();
    pixmap.fill(tiny_skia::Color::from_rgba8(255, 0, 0, 255));
    let png = crate::images::encode_png(&pixmap);
    let hash = "00112233445566778899aabbccddeeff00112233";
    assert_eq!(doc.add_image(hash, png), Some((4, 2)));
    apply(
        &mut doc,
        &format!(r#"[{{"op":"set","ids":["1:3"],"props":{{"fills":[{{"image":"{hash}"}}]}}}}]"#),
    );
    let reopened = Document::open(&save(&doc, &original).unwrap()).unwrap();
    assert!(reopened.images.contains_key(hash));
    let fill = &find(&reopened, "1:3").fills()[0];
    assert!(matches!(&fill.kind, PaintKind::Image(i) if i.hash.as_deref() == Some(hash)));
    let scene = Scene::build(&reopened, reopened.pages[0]);
    let pixels = render::render(
        &reopened,
        &scene,
        &mut ImageStore::default(),
        &Viewport {
            x: 0.0,
            y: 0.0,
            scale: 1.0,
            width: 200,
            height: 200,
        },
        RenderOptions::default(),
    )
    .unwrap();
    let c = pixels.pixel(50, 40).unwrap();
    assert_eq!(
        (c.red(), c.green(), c.blue()),
        (255, 0, 0),
        "the image fills the rectangle"
    );
}

#[test]
fn saves_text_styles() {
    let bytes = blank("Type");
    let mut doc = Document::open(&bytes).unwrap();
    let created = apply(
        &mut doc,
        r#"[{"op":"create","parent":"0:1","node":{"type":"TEXT","x":0,"y":0,"width":1,"height":1,"props":{"characters":"Styled","fontSize":20,"fontStyle":"Semi Bold","lineHeight":{"value":150,"unit":"PERCENT"},"letterSpacing":{"value":2,"unit":"PERCENT"},"textDecoration":"UNDERLINE","textCase":"UPPER","textAlignHorizontal":"CENTER"}}}]"#,
    );
    let before = find(&doc, &created[0]).clone();
    let reopened = Document::open(&save(&doc, &bytes).unwrap()).unwrap();
    let text = find(&reopened, &created[0]);
    let style = text.text_style.as_deref().unwrap();
    assert_eq!(style.font_style.as_deref(), Some("Semi Bold"));
    assert_eq!(style.line_height, Some((1.5, "RAW".into())));
    assert_eq!(style.letter_spacing, Some((2.0, "PERCENT".into())));
    assert_eq!(style.decoration.as_deref(), Some("UNDERLINE"));
    assert_eq!(style.case.as_deref(), Some("UPPER"));
    assert_eq!(style.align_horizontal.as_deref(), Some("CENTER"));
    let layout = text.text_layout.as_deref().unwrap();
    assert_eq!(
        layout.decorations,
        before.text_layout.as_deref().unwrap().decorations
    );
    assert_eq!(layout.glyphs.len(), 6);
}

#[test]
fn draws_and_saves_arrows() {
    let bytes = blank("Lines");
    let mut doc = Document::open(&bytes).unwrap();
    let created = apply(
        &mut doc,
        r#"[{"op":"create","parent":"0:1","node":{"type":"LINE","name":"Arrow","x":0,"y":50,"width":100,"height":0,"props":{"rotation":-90,"strokeCap":"ARROW_LINES","strokeWeight":2}}}]"#,
    );
    let line = find(&doc, &created[0]).clone();
    assert_eq!(line.size().y, 0.0);
    assert_eq!(line.stroke_cap.as_deref(), Some("ARROW_LINES"));
    // A quarter turn clockwise about its middle: it runs down from (50, 0).
    let t = line.transform();
    assert!((t.m02 - 50.0).abs() < 1e-6 && t.m12.abs() < 1e-6, "{t:?}");
    let scene = Scene::build(&doc, doc.pages[0]);
    let b = scene.node(scene.root()).bounds;
    assert!(b.w >= 8.0 && b.h >= 100.0, "the arrowhead is inside: {b:?}");
    let reopened = Document::open(&save(&doc, &bytes).unwrap()).unwrap();
    let r = find(&reopened, &created[0]);
    assert_eq!(r.stroke_cap.as_deref(), Some("ARROW_LINES"));
    assert_eq!(r.node_type(), NodeType::Line);
}