mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-24 17:56:50 -06:00
Louise FoxandClaude Opus 5.5
24936cd006
A plug-in could filter objects or reshape them as a live effect, but
nothing it made could leave the app: pen plotters, cutting machines and
laser cutters read formats VectorCraft doesn't write. An exporter is a
third kind of plug-in ("kind": "exporter", with the file "extensions"
it writes), in the same sandbox and with the same ABI v1 exports.
- It adds a write-only format, plugin.<id>. document.formats lists it
with its plug-in id, and document.export writes it by that id, or by
a path ending in one of its extensions that no built-in format has;
"params" carries its parameters, checked against its manifest as a
filter's are.
- File › Export › Export As lists it after the built-in formats, with
Use Artboards greyed out, since the plug-in writes the whole
document. One with parameters asks for them in a dialog generated
from its schema (pluginExport) once the file is picked.
- The plug-in is given the native file's JSON (format::json_part:
images of 8 KiB or more without their data) and _context {mode:
"export", extension, name}. It returns {"dataBase64", "warnings"?}
or {"error"}. The host writes the file, and nothing when the plug-in
declines or returns bad data.
- An export gets 10 G instructions plus 4,000 per byte and 300 s.
Background Export's Cancel stops it between two slices of that
budget (Error::Cancelled), and a cancelled live-effect run is not
cached as a failure.
- plugin.run and Object › Plug-ins say where an exporter is instead of
calling it a live effect.
engine/tests/plugin_export.rs reads back what an exporter is handed
with wat::echo_exporter, an exporter whose file is its input or its
parameters (its base64 encoder is written in WAT). The document it is
given is document.save's JSON, without the large image's data, and its
parameters arrive defaulted, clamped and with the file's name and
extension. It also covers listing and removal, built-in extensions
winning, selectedOnly, declines, bad base64, missing data, warnings,
and Cancel stopping a plug-in that never returns. It is a test binary
of its own: installed plug-ins are process-wide, and the format-list
unit tests check exact lists. dialogs/tests_plugin_export.rs drives
Export As headlessly; plugins/tests/abi.rs covers the budget, the
parameters and the echo exporter; format/tests/native_v4.rs covers
json_part.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HhvnnnD5fTFupK8WWq35un
92 lines
4.3 KiB
Rust
92 lines
4.3 KiB
Rust
//! `.vectorcraft` v4: large data after the JSON (images, the PDF, profiles), small files still plain
|
||
//! JSON, older versions inline, damaged offsets refused.
|
||
// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
|
||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||
|
||
use std::sync::Arc;
|
||
|
||
use serde_json::Value;
|
||
use vectorcraft_doc::{Document, ImageBlob, ImageObject, Node, NodeKind};
|
||
use vectorcraft_format::{BLOB_MAGIC, FormatError, INLINE_MAX, SaveOptions, load, load_file, pdf_content, save_with};
|
||
use vectorcraft_geom::Affine;
|
||
|
||
/// A document showing image `key` of `len` bytes.
|
||
fn doc_with_image(key: &str, len: usize) -> Document {
|
||
let mut d = Document::new(100.0, 100.0);
|
||
let bytes: Vec<u8> = (0..len).map(|i| (i * 7 % 251) as u8).collect();
|
||
d.images.insert(key.into(), ImageBlob::new("image/png", bytes));
|
||
let l = d.layers[0].id;
|
||
let id = d.alloc_id();
|
||
let im = ImageObject { key: key.into(), width: 10, height: 10, xf: Affine::IDENTITY, link: None, placement: Default::default() };
|
||
d.insert(Some(l), 0, Node::new(id, NodeKind::Image(Box::new(im)))).unwrap();
|
||
d
|
||
}
|
||
|
||
fn has_tail(bytes: &[u8]) -> bool {
|
||
bytes.windows(BLOB_MAGIC.len()).any(|w| w == BLOB_MAGIC)
|
||
}
|
||
|
||
#[test]
|
||
fn large_data_goes_after_the_json_and_reads_back() {
|
||
let d = doc_with_image("big", INLINE_MAX + 10);
|
||
let pdf = vec![b'%'; INLINE_MAX * 2];
|
||
for compress in [false, true] {
|
||
let o = SaveOptions { compress, pdf: Some(pdf.clone()), ..SaveOptions::default() };
|
||
let bytes = save_with(&d, &o).unwrap();
|
||
if !compress {
|
||
assert!(has_tail(&bytes), "a binary section");
|
||
// The JSON before it holds no base64 copy of the image.
|
||
assert!(bytes.len() < INLINE_MAX + 10 + pdf.len() + (32 << 10), "{} bytes", bytes.len());
|
||
}
|
||
let back = load(&bytes).unwrap();
|
||
assert_eq!(back.images["big"].bytes, d.images["big"].bytes, "compress {compress}");
|
||
assert_eq!(pdf_content(&bytes).unwrap(), pdf);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn small_files_stay_plain_json_and_older_versions_inline() {
|
||
let small = save_with(&doc_with_image("small", 100), &SaveOptions::default()).unwrap();
|
||
assert!(!has_tail(&small));
|
||
let v: Value = serde_json::from_slice(&small).unwrap();
|
||
assert_eq!(v["version"], 4);
|
||
let big = doc_with_image("big", INLINE_MAX + 10);
|
||
let v3 = save_with(&big, &SaveOptions { version: 3, ..SaveOptions::default() }).unwrap();
|
||
assert!(!has_tail(&v3), "version 3 keeps everything in the JSON");
|
||
let v: Value = serde_json::from_slice(&v3).unwrap();
|
||
assert_eq!((v["format"].as_str(), v["version"].as_u64()), (Some("vectorcraft"), Some(3)));
|
||
assert_eq!(load(&v3).unwrap().images["big"].bytes, big.images["big"].bytes);
|
||
}
|
||
|
||
/// `json_part` (what exporter plug-ins are given): the whole JSON value, without the data after
|
||
/// it; a file without such data is its JSON already.
|
||
#[test]
|
||
fn json_part_is_the_json_without_the_data_after_it() {
|
||
let big = save_with(&doc_with_image("big", INLINE_MAX + 10), &SaveOptions::default()).unwrap();
|
||
let json = vectorcraft_format::json_part(&big);
|
||
assert!(json.len() < big.len() - INLINE_MAX && !has_tail(json));
|
||
let v: Value = serde_json::from_slice(json).unwrap();
|
||
assert!(v["images"]["big"].get("blob").is_some() && v["images"]["big"].get("data").is_none(), "{}", v["images"]);
|
||
let small = save_with(&doc_with_image("small", 100), &SaveOptions::default()).unwrap();
|
||
assert_eq!(vectorcraft_format::json_part(&small), &small[..]);
|
||
}
|
||
|
||
#[test]
|
||
fn damaged_offsets_are_refused_not_a_crash() {
|
||
let d = doc_with_image("big", INLINE_MAX + 10);
|
||
let bytes = save_with(&d, &SaveOptions::default()).unwrap();
|
||
// The data cut short.
|
||
let cut = &bytes[..bytes.len() - 100];
|
||
assert!(matches!(load_file(cut), Err(FormatError::BadImage(_))));
|
||
// An offset past the end.
|
||
let text = String::from_utf8_lossy(&bytes);
|
||
let at = text.find("\"blob\":[").unwrap();
|
||
let mut damaged = bytes.clone();
|
||
damaged.splice(at..at + 8, b"\"blob\":[9".iter().copied());
|
||
assert!(load_file(&damaged).is_err());
|
||
// A missing section.
|
||
let json_only = &bytes[..bytes.windows(BLOB_MAGIC.len()).position(|w| w == BLOB_MAGIC).unwrap()];
|
||
assert!(load_file(json_only).is_err());
|
||
let _ = Arc::new(());
|
||
}
|