Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

20.1 KB
Raw Blame
//! SVG Options through the engine: every option changes the output, artboards write one file
//! each, junk is rejected, and Save writes SVG with remembered options.

use serde_json::{Value, json};

use super::*;

fn session(artboards: usize) -> Session {
    let mut s = Session::new();
    s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": artboards})).unwrap();
    s.execute("shape.rectangle", &json!({"x": 10.123456, "y": 10, "width": 50, "height": 40})).unwrap();
    s
}

pub(super) fn svg(s: &mut Session, p: Value) -> String {
    let mut p = p;
    p["format"] = json!("svg");
    s.execute("document.serialize", &p).unwrap_or_else(|e| panic!("{p}: {e}"))["text"].as_str().unwrap().to_string()
}

fn tmp_dir(tag: &str) -> std::path::PathBuf {
    let d = std::env::temp_dir().join(format!("vc-svgopts-{tag}-{}", std::process::id()));
    std::fs::create_dir_all(&d).unwrap();
    d
}

/// A session whose document holds one embedded 2×2 PNG.
pub(super) fn image_session() -> Session {
    let mut png = Vec::new();
    image::RgbaImage::from_pixel(2, 2, image::Rgba([10, 200, 30, 255]))
        .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
        .unwrap();
    let mut s = Session::new();
    s.execute("document.open", &json!({"name": "dot.png", "dataBase64": vectorcraft_format::base64_encode(&png)})).unwrap();
    s
}

#[test]
fn every_option_changes_the_output() {
    let mut s = session(1);
    let plain = svg(&mut s, json!({}));
    assert!(plain.contains("fill=\"#") && plain.contains(" width=\"200\"") && plain.contains("id=\"Layer_1\""), "{plain}");
    let changed = |s: &mut Session, p: Value, check: &dyn Fn(&str) -> bool| {
        let out = svg(s, p.clone());
        assert_ne!(out, plain, "{p} changed nothing");
        assert!(check(&out), "{p}:\n{out}");
    };
    changed(&mut s, json!({"styling": "style"}), &|o| o.contains("style=\"fill:#"));
    changed(&mut s, json!({"styling": "entities"}), &|o| o.contains("<!ENTITY st1 ") && o.contains("style=\"&st1;\""));
    changed(&mut s, json!({"svg": {"styling": "css"}}), &|o| o.contains("<style>") && o.contains("class=\"cls-1\""));
    changed(&mut s, json!({"objectIds": "minimal"}), &|o| !o.contains(" id=\""));
    changed(&mut s, json!({"objectIds": "unique"}), &|o| o.contains(" id=\"u") && o.contains("-Layer_1\""));
    changed(&mut s, json!({"decimals": 1}), &|o| o.contains("x=\"10.1\"") && !o.contains("10.123"));
    changed(&mut s, json!({"decimals": 6}), &|o| o.contains("10.123456"));
    changed(&mut s, json!({"minify": true}), &|o| !o.trim_end().contains('\n') && !o.contains("<?xml"));
    changed(&mut s, json!({"responsive": true}), &|o| !o.contains(" width=\"200\"") && o.contains("viewBox=\"0 0 200 100\""));
    changed(&mut s, json!({"useArtboards": false}), &|o| !o.contains("viewBox=\"0 0 200 100\""));
    changed(&mut s, json!({"metadata": true}), &|o| o.contains("<metadata>") && o.contains("<dc:format>image/svg+xml</dc:format>"));
    changed(&mut s, json!({"preserveEditing": true}), &|o| o.contains(vectorcraft_svg::EDITING_NS));
    s.execute("text.create", &json!({"x": 20, "y": 80, "text": "Hi"})).unwrap();
    let with_text = svg(&mut s, json!({}));
    assert!(with_text.contains("<text"));
    assert!(!svg(&mut s, json!({"outlineText": true})).contains("<text"), "Fonts → outlines");
    // The nested object wins over the top level.
    assert!(svg(&mut s, json!({"styling": "style", "svg": {"styling": "css"}})).contains("<style>"));

    let mut s = image_session();
    assert!(svg(&mut s, json!({})).contains("href=\"data:image/png;base64,"));
    let r = s.execute("document.serialize", &json!({"format": "svg", "images": "link"})).unwrap();
    let name = r["linked"][0]["name"].as_str().unwrap().to_string();
    assert!(name.ends_with(".png") && r["text"].as_str().unwrap().contains(&format!("href=\"{name}\"")), "{r}");
}

#[test]
fn junk_options_are_rejected() {
    let mut s = session(1);
    for p in [
        json!({"styling": "fancy"}),
        json!({"objectIds": true}),
        json!({"decimals": 0}),
        json!({"decimals": 8}),
        json!({"svg": {"bogus": 1}}),
        json!({"svg": "css"}),
        json!({"images": "inline"}),
        json!({"useArtboards": "yes"}),
    ] {
        let mut q = p.clone();
        q["format"] = json!("svg");
        assert!(s.execute("document.export", &q).is_err(), "{p} was accepted");
    }
    // Other formats ignore the SVG options.
    assert!(s.execute("document.export", &json!({"format": "png", "styling": "fancy"})).is_ok());
}

#[test]
fn several_artboards_write_one_file_each() {
    let mut s = session(3);
    s.execute("artboard.setProps", &json!({"index": 0, "name": "Cover"})).unwrap();
    let dir = tmp_dir("boards");
    let path = dir.join("art.svg").to_string_lossy().to_string();
    let r = s.execute("document.export", &json!({"path": path, "range": "all"})).unwrap();
    let files: Vec<&str> = r["files"].as_array().unwrap().iter().map(|f| f.as_str().unwrap()).collect();
    let names: Vec<&str> = files.iter().map(|f| f.rsplit(['/', '\\']).next().unwrap()).collect();
    assert_eq!(names, ["art-Cover.svg", "art-Artboard-2.svg", "art-Artboard-3.svg"]);
    for f in &files {
        assert!(std::fs::read_to_string(f).unwrap().contains("viewBox=\"0 0 200 100\""), "{f}");
    }
    let r = s.execute("document.export", &json!({"format": "svg", "svg": {"range": "2-3"}})).unwrap();
    assert_eq!(r["files"].as_array().unwrap().len(), 2, "{r}");
    let r = s.execute("document.serialize", &json!({"format": "svg", "range": "all"})).unwrap();
    assert_eq!(r["files"].as_array().unwrap().len(), 3);
    assert!(r["files"][2]["text"].as_str().unwrap().starts_with("<?xml"));
    let _ = std::fs::remove_dir_all(dir);
}

#[test]
fn linked_images_are_written_next_to_the_svg() {
    let mut s = image_session();
    let dir = tmp_dir("linked");
    let path = dir.join("pic.svg").to_string_lossy().to_string();
    let r = s.execute("document.export", &json!({"path": path, "images": "link"})).unwrap();
    let linked = r["linked"][0].as_str().unwrap();
    assert!(image::load_from_memory(&std::fs::read(linked).unwrap()).is_ok(), "{linked}");
    let text = std::fs::read_to_string(&path).unwrap();
    let name = std::path::Path::new(linked).file_name().unwrap().to_string_lossy().to_string();
    assert!(text.contains(&format!("href=\"{name}\"")), "{text}");
    assert!(s.execute("document.exportSelection", &json!({"format": "svg", "images": "link"})).is_err(), "nowhere to put the images");
    let _ = std::fs::remove_dir_all(dir);
}

#[test]
fn preserve_editing_reopens_the_native_document() {
    let mut s = session(2);
    s.execute("artboard.setProps", &json!({"index": 1, "name": "Back"})).unwrap();
    let text = svg(&mut s, json!({"preserveEditing": true}));
    let r = s.execute("document.open", &json!({"name": "both.svg", "dataBase64": vectorcraft_format::base64_encode(text.as_bytes())})).unwrap();
    assert_eq!(r["format"], "svg");
    let doc = &s.doc().unwrap().doc;
    assert_eq!(doc.artboards.len(), 2, "both artboards came back");
    assert_eq!(doc.artboards[1].name, "Back");
    assert_eq!(doc.title, "both.svg");
    // Without it the SVG is imported (one artboard).
    let text = svg(&mut s, json!({}));
    s.execute("document.open", &json!({"name": "plain.svg", "dataBase64": vectorcraft_format::base64_encode(text.as_bytes())})).unwrap();
    assert_eq!(s.doc().unwrap().doc.artboards.len(), 1);
}

#[test]
fn saving_several_artboards_as_plain_svg_warns_they_are_lost() {
    let artboards = |r: &Value| r["warnings"].as_array().unwrap().iter().filter(|w| w.as_str().unwrap().contains("artboards")).count();
    let mut s = session(3);
    let r = s.execute("document.save", &json!({"format": "svg"})).unwrap();
    assert_eq!(artboards(&r), 1, "{r}");
    // First: the status bar shows only the first warning.
    assert!(r["warnings"][0].as_str().unwrap().contains("1 of the document's 3 artboards"), "{r}");
    assert_eq!(artboards(&s.execute("file.saveAs", &json!({"format": "svgz"})).unwrap()), 1);
    // Preserve Editing keeps them all (they reopen); a single artboard loses none.
    for p in [json!({"format": "svg", "preserveEditing": true}), json!({"format": "svg", "svg": {"preserveEditing": true}})] {
        let r = s.execute("document.save", &p).unwrap();
        assert_eq!(artboards(&r), 0, "{p}: {r}");
    }
    assert_eq!(artboards(&session(1).execute("document.save", &json!({"format": "svg"})).unwrap()), 0);
}

/// #3867: a Preserve Editing SVG opened from disk and saved with plain Save keeps the full
/// document (every artboard), not just the artwork of the first.
#[test]
fn reopened_preserve_editing_svg_saves_as_the_full_document() {
    let dir = tmp_dir("reopen");
    let path = dir.join("keep.svg").to_string_lossy().to_string();
    session(3).execute("document.save", &json!({"path": path, "svg": {"preserveEditing": true}})).unwrap();
    let mut s = Session::new();
    s.execute("document.open", &json!({"path": path})).unwrap();
    assert_eq!(s.doc().unwrap().doc.artboards.len(), 3);
    s.execute("document.save", &json!({})).unwrap();
    let mut t = Session::new();
    let r = t.execute("document.open", &json!({"path": path})).unwrap();
    assert_eq!(r["restored"], json!(true), "{r}");
    assert_eq!(t.doc().unwrap().doc.artboards.len(), 3, "every artboard survives open and Save");
    let _ = std::fs::remove_dir_all(dir);
}

/// #3869: small capitals, superscript and subscript, and tab leaders, which SVG text can't draw,
/// are written as outlines (as vertical type and ruby are) rather than as plain text at full size;
/// type without them stays text.
#[test]
fn type_svg_text_cant_draw_is_written_as_outlines() {
    let mut s = Session::new();
    s.execute("file.new", &json!({"width": 500, "height": 200})).unwrap();
    s.execute("text.create", &json!({"x": 50, "y": 100, "text": "Small caps x2 H2O", "size": 30})).unwrap();
    let plain = svg(&mut s, json!({}));
    assert!(plain.contains("<text"), "plain type stays text: {plain}");
    for style in [json!({"smallCaps": true}), json!({"position": "superscript"}), json!({"position": "subscript"})] {
        let mut t = Session::new();
        t.execute("file.new", &json!({"width": 500, "height": 200})).unwrap();
        let id = t.execute("text.create", &json!({"x": 50, "y": 100, "text": "Small caps x2 H2O", "size": 30})).unwrap()["id"].clone();
        let mut p = style.clone();
        p["id"] = id;
        p["start"] = json!(0);
        p["end"] = json!(5);
        t.execute("text.setRangeStyle", &p).unwrap();
        let out = svg(&mut t, json!({}));
        assert!(!out.contains("<text") && out.contains("<path"), "{style}: {out}");
    }
}

#[test]
fn save_writes_svg_and_remembers_its_options() {
    let mut s = session(1);
    let dir = tmp_dir("save");
    let path = dir.join("doc.svg").to_string_lossy().to_string();
    let r = s.execute("document.save", &json!({"path": path, "svg": {"styling": "css", "decimals": 2}})).unwrap();
    assert_eq!(r["path"], json!(path));
    assert!(std::fs::read_to_string(&path).unwrap().contains("<style>"));
    let st = s.doc().unwrap();
    assert_eq!(st.path.as_deref(), Some(path.as_str()));
    assert!(!st.is_dirty());
    s.execute("shape.ellipse", &json!({"x": 100, "y": 10, "width": 30, "height": 30})).unwrap();
    s.execute("document.save", &json!({})).unwrap();
    let text = std::fs::read_to_string(&path).unwrap();
    assert!(text.contains("<style>") && vectorcraft_testkit::svg_shapes(&text) == 2, "Save reuses the options: {text}");
    assert!(s.execute("document.save", &json!({"path": dir.join("x.png").to_string_lossy()})).is_err(), "PNG is an export");
    // A native save switches back.
    let native = dir.join("doc.vectorcraft").to_string_lossy().to_string();
    s.execute("document.save", &json!({"path": native})).unwrap();
    assert!(vectorcraft_format::sniff(&std::fs::read(&native).unwrap()));
    assert!(s.doc().unwrap().save_options.is_empty(), "a native save remembers no options");
    let _ = std::fs::remove_dir_all(dir);
}

#[test]
fn formats_list_the_svg_options_with_their_defaults() {
    let mut s = Session::new();
    let r = s.execute("document.formats", &json!({})).unwrap();
    let svg = r["formats"].as_array().unwrap().iter().find(|f| f["id"] == "svg").unwrap();
    let defaults = serde_json::to_value(vectorcraft_svg::ExportOptions::default()).unwrap();
    for (k, v) in defaults.as_object().unwrap() {
        assert_eq!(&svg["options"][k]["default"], v, "{k}");
    }
    for k in ["useArtboards", "range", "svg"] {
        assert!(svg["options"].get(k).is_some(), "{k}");
    }
}

#[test]
fn fewer_tspans_reaches_the_writer() {
    let mut s = Session::new();
    let src = r##"<svg xmlns="http://www.w3.org/2000/svg" width="200" height="100"><text x="10" y="40" font-size="12">plain <tspan fill="#ff0000">red</tspan> plain</text></svg>"##;
    s.execute("document.open", &json!({"name": "two-runs.svg", "dataBase64": vectorcraft_format::base64_encode(src.as_bytes())})).unwrap();
    let placed = |svg: &str| svg.matches("<tspan x=").count();
    assert_eq!(placed(&svg(&mut s, json!({}))), 3, "a tspan per style run");
    assert_eq!(placed(&svg(&mut s, json!({"fewerTspans": true}))), 1, "a tspan per line");
}

/// Gunzip SVGZ bytes.
fn gunzip(bytes: &[u8]) -> String {
    assert!(vectorcraft_svg::is_svgz(bytes), "gzip magic");
    vectorcraft_svg::text_of(bytes).unwrap().into_owned()
}

#[test]
fn svgz_is_the_svg_export_gzipped() {
    let mut s = session(2);
    let opts = json!({"styling": "css", "range": "2"});
    let mut p = opts.clone();
    p["format"] = json!("svgz");
    let svgz = vectorcraft_format::base64_decode(s.execute("document.serialize", &p).unwrap()["dataBase64"].as_str().unwrap()).unwrap();
    assert_eq!(gunzip(&svgz), svg(&mut s, opts));
    // The format comes from the extension too, and Save writes it.
    let dir = tmp_dir("svgz");
    let path = dir.join("art.svgz").to_string_lossy().to_string();
    s.execute("document.export", &json!({"path": path, "range": "all"})).unwrap();
    assert!(gunzip(&std::fs::read(dir.join("art-Artboard-1.svgz")).unwrap()).contains("<svg"));
    let saved = dir.join("saved.svgz").to_string_lossy().to_string();
    s.execute("document.save", &json!({"path": saved, "svg": {}})).unwrap();
    assert!(gunzip(&std::fs::read(&saved).unwrap()).contains("<svg"));
    assert_eq!(s.doc().unwrap().path.as_deref(), Some(saved.as_str()));
    let _ = std::fs::remove_dir_all(dir);
}

#[test]
fn svgz_opens_and_pastes_like_svg() {
    let mut s = session(1);
    s.execute("shape.ellipse", &json!({"x": 100, "y": 20, "width": 40, "height": 30})).unwrap();
    let text = svg(&mut s, json!({}));
    let open = |s: &mut Session, name: &str, bytes: &[u8]| {
        s.execute("document.open", &json!({"name": name, "dataBase64": vectorcraft_format::base64_encode(bytes)})).unwrap();
        let mut doc = (*s.doc().unwrap().doc).clone();
        doc.title.clear();
        vectorcraft_format::save(&doc, false)
    };
    let plain = open(&mut s, "a.svg", text.as_bytes());
    // Detected by the magic bytes whatever the name says.
    assert_eq!(open(&mut s, "a.svg", &vectorcraft_svg::compress(&text)), plain);
    assert_eq!(open(&mut s, "a.svgz", &vectorcraft_svg::compress(&text)), plain);
    let r = s.execute("clipboard.importSvg", &json!({"dataBase64": vectorcraft_format::base64_encode(&vectorcraft_svg::compress(&text))})).unwrap();
    assert_eq!(r["count"], 2);
    assert!(s.execute("document.open", &json!({"name": "bad.svgz", "dataBase64": vectorcraft_format::base64_encode(&[0x1f, 0x8b, 1, 2])})).is_err());
}

#[test]
fn svg_darkness_preserves_source_model_and_gradient_appearance() {
    use vectorcraft_color::{Color, Gradient, GradientKind, GradientPaint, GradientStop, Paint};
    use vectorcraft_doc::{ColorMode, Effect};
    use vectorcraft_geom::Rect;
    for kind in ["rgb", "cmykSource", "gradient", "cmykDocument"] {
        let mut s = session(1);
        s.edit("paint source", |d, _| {
            if kind == "cmykDocument" {
                d.color_mode = ColorMode::Cmyk;
            }
            let id = d.layers[0].children().unwrap()[0].id;
            let n = d.node_mut(id).unwrap();
            n.appearance.fill_mut().unwrap().paint = match kind {
                "cmykSource" => Paint::solid(Color::cmyk(0.15, 0.3, 0.4, 0.2)),
                "gradient" => Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(
                    GradientKind::Linear,
                    vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::rgb(0.8, 0.4, 0.2))],
                )))),
                _ => Paint::solid(Color::rgb(0.8, 0.4, 0.2)),
            };
            n.appearance.items.retain(|i| i.is_fill());
            n.appearance.effects = vec![Effect {
                id: "stylize.dropShadow".into(),
                visible: true,
                params: json!({"shade":"darkness","darkness":25,"x":60,"y":0,"blur":0,"opacity":100,"mode":"normal"}),
            }];
            Ok(())
        })
        .unwrap();
        let native = s.doc().unwrap().doc.clone();
        let text = svg(&mut s, json!({}));
        if kind == "rgb" {
            assert!(text.contains("feComponentTransfer") && !text.contains("<image"));
        } else {
            assert!(text.contains("<image"), "{kind}: the shadow must preserve rendered appearance");
        }
        let back = vectorcraft_svg::import(&text).unwrap();
        let region = Rect::new(0.0, 0.0, 200.0, 100.0);
        let expected = vectorcraft_render::Renderer::new().render_region(&native, region, 1.0, true);
        let actual = vectorcraft_render::Renderer::new().render_region(&back, region, 1.0, true);
        for x in 80..115 {
            let (a, b) = (actual.pixel(x, 30), expected.pixel(x, 30));
            assert!(a.iter().zip(b).all(|(a, b)| a.abs_diff(b) <= 8), "{kind} at {x}: {a:?} vs {b:?}");
        }
    }
}

#[test]
fn svg_darkness_uses_rendered_shadow_in_non_srgb_working_space() {
    const CHILD: &str = "VECTORCRAFT_TEST_SHADOW_RGB_PROFILE";
    if std::env::var_os(CHILD).is_none() {
        // Color settings are process-wide: exercise this profile in a separate test process.
        let output = std::process::Command::new(std::env::current_exe().unwrap())
            .args(["--exact", "cmd::fileio::tests_svg::svg_darkness_uses_rendered_shadow_in_non_srgb_working_space", "--nocapture"])
            .env(CHILD, "1")
            .output()
            .unwrap();
        let stdout = String::from_utf8_lossy(&output.stdout);
        assert!(
            output.status.success() && stdout.contains("test result: ok. 1 passed; 0 failed;"),
            "isolated color profile test failed:\n{stdout}\n{}",
            String::from_utf8_lossy(&output.stderr),
        );
        return;
    }
    use vectorcraft_color::{Color, Paint, cms};
    let settings = cms::ColorSettings { rgb: cms::WIDE_GAMUT_RGB.into(), ..Default::default() };
    cms::set_active(&settings).unwrap();
    assert!(!cms::active().rgb_is_srgb());
    let mut s = session(1);
    s.edit("RGB source", |d, _| {
        let id = d.layers[0].children().unwrap()[0].id;
        let n = d.node_mut(id).unwrap();
        n.appearance.fill_mut().unwrap().paint = Paint::solid(Color::rgb(0.8, 0.4, 0.2));
        n.appearance.items.retain(|i| i.is_fill());
        n.appearance.effects = vec![vectorcraft_doc::Effect {
            id: "stylize.dropShadow".into(),
            visible: true,
            params: json!({"shade":"darkness","darkness":25,"x":60,"y":0,"blur":0,"opacity":100,"mode":"normal"}),
        }];
        Ok(())
    })
    .unwrap();
    let region = vectorcraft_geom::Rect::new(0.0, 0.0, 200.0, 100.0);
    let expected = vectorcraft_render::Renderer::new().render_region(&s.doc().unwrap().doc, region, 1.0, true);
    let text = svg(&mut s, json!({}));
    assert!(text.contains("<image"), "a non-sRGB source must preserve its adjusted rendered colors");
    cms::set_active(&cms::ColorSettings::default()).unwrap();
    let back = vectorcraft_svg::import(&text).unwrap();
    let actual = vectorcraft_render::Renderer::new().render_region(&back, region, 1.0, true);
    for x in 80..115 {
        let (a, b) = (actual.pixel(x, 30), expected.pixel(x, 30));
        assert!(a.iter().zip(b).all(|(a, b)| a.abs_diff(b) <= 8), "at {x}: {a:?} vs {b:?}");
    }
}