VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Native format: a document is saved pretty-printed only when its pretty-printed JSON is at most 1 MiB
dotCooCoo0635357eb9b7
diff --git a/crates/engine/src/cmd/fileio/native.rs b/crates/engine/src/cmd/fileio/native.rsindex f6eab1978..bcca24c34 100644--- a/crates/engine/src/cmd/fileio/native.rs+++ b/crates/engine/src/cmd/fileio/native.rs@@ -146,10 +146,13 @@ pub(super) struct Extras {/// are left to [`encode`]).pub(super) fn save_options(cmd: &str, f: &Format, doc: &Document, p: &Value) -> Result<(SaveOptions, Extras)> {let o: NativeOptions = super::encode::options(f, p)?;- let mut so = SaveOptions::for_doc(doc);- so.compress = o.compress.unwrap_or(false);- so.version = o.version.unwrap_or(vectorcraft_format::VERSION);- so.include_linked = o.include_linked;+ // Pretty or compact is decided by [`encode_to`] on the document it writes.+ let mut so = SaveOptions {+ compress: o.compress.unwrap_or(false),+ version: o.version.unwrap_or(vectorcraft_format::VERSION),+ include_linked: o.include_linked,+ ..SaveOptions::default()+ };if o.embed_profiles.unwrap_or(true) {so.profiles = embedded_profiles(doc);}@@ -190,6 +193,7 @@ pub(super) fn encode_to(cmd: &str, f: &Format, doc: &Document, p: &Value, w: imp}other => other,};+ so.pretty = so.pretty_fits(&native);vectorcraft_format::save_to(&native, &so, w).map_err(|e| bad(cmd, e.to_string()))}diff --git a/crates/engine/src/tests_nativefile.rs b/crates/engine/src/tests_nativefile.rsindex a9d694c88..de547d6a4 100644--- a/crates/engine/src/tests_nativefile.rs+++ b/crates/engine/src/tests_nativefile.rs@@ -96,6 +96,31 @@ fn saves_for_older_versions() {}}+#[test]+fn an_older_version_is_pretty_only_when_its_own_json_fits() {+ // One path whose anchors fit the pretty size limit in the current version but not as+ // version 1 writes them (both handles of every anchor as `{x, y}` maps).+ use vectorcraft_geom::Point;+ use vectorcraft_geom::path::{PathData, SubPath};+ let path_doc = |anchors: usize| {+ let mut b = vectorcraft_testkit::fixtures::DocBuilder::new(1000.0, 1000.0);+ let points: Vec<Point> = (0..anchors).map(|j| Point::new(j as f64, (j % 2) as f64)).collect();+ let node = b.path_node(PathData::single(SubPath::polyline(&points, false)), Default::default());+ b.add(node);+ b.doc+ };+ let per_anchor = serde_json::to_vec_pretty(&path_doc(1000)).unwrap().len() / 1000;+ let d = path_doc(vectorcraft_format::PRETTY_MAX_BYTES / 2 / per_anchor);+ let mut s = Session::new();+ open(&mut s, "traced.vectorcraft", &vectorcraft_format::save_file(&d));+ let is_pretty = |bytes: &[u8]| bytes.windows(3).any(|w| w == b"\n ");+ assert!(is_pretty(&saved(&mut s, json!({"compress": false}))));+ let old = saved(&mut s, json!({"version": 1}));+ assert!(!is_pretty(&old), "{} bytes", old.len());+ open(&mut s, "old.drawcraft", &old);+ assert_eq!(s.doc().unwrap().doc.node_count(), 2);+}+#[test]fn preview_is_at_most_256_pixels() {let mut s = session();diff --git a/crates/format/src/lib.rs b/crates/format/src/lib.rsindex f4bdeb42c..d76453bee 100644--- a/crates/format/src/lib.rs+++ b/crates/format/src/lib.rs@@ -253,17 +253,25 @@ impl SaveOptions {Ok(())}- /// The defaults for saving `doc` to disk: pretty when small (see [`PRETTY_MAX_OBJECTS`] and- /// [`PRETTY_MAX_BYTES`]).+ /// The defaults for saving `doc` to disk: pretty when small (see [`Self::pretty_fits`]).pub fn for_doc(doc: &Document) -> Self {+ let o = Self::default();+ Self { pretty: o.pretty_fits(doc), ..o }+ }++ /// Is `doc` small enough to save pretty-printed with these options: at most+ /// [`PRETTY_MAX_OBJECTS`] objects, and at most [`PRETTY_MAX_BYTES`] of pretty-printed JSON+ /// as [`save_to`] writes the document with them (in their version)?+ pub fn pretty_fits(&self, doc: &Document) -> bool {let objects: usize = doc.layers.iter().map(|l| l.count()).sum();- Self { pretty: objects <= PRETTY_MAX_OBJECTS && compact_size_at_most(doc, PRETTY_MAX_BYTES), ..Self::default() }+ objects <= PRETTY_MAX_OBJECTS && body(doc, self).is_ok_and(|b| pretty_size_at_most(&b, PRETTY_MAX_BYTES))}}-/// Is `doc` at most `limit` bytes as compact JSON? Serializing stops as soon as it is past the-/// limit, so a large document costs no more than `limit` bytes of work.-fn compact_size_at_most(doc: &Document, limit: usize) -> bool {+/// Is the document in `b` at most `limit` bytes as pretty-printed JSON, indented as a pretty file+/// holds it? Serializing stops as soon as it is past the limit, so a large document costs no more+/// than `limit` bytes of work.+fn pretty_size_at_most(b: &Body, limit: usize) -> bool {struct Capped {left: usize,}@@ -276,7 +284,47 @@ fn compact_size_at_most(doc: &Document, limit: usize) -> bool {Ok(())}}- serde_json::to_writer(Capped { left: limit }, doc).is_ok()+ // The document is a member of the file's top-level object, indented one level more.+ write_body(Indent { inner: Capped { left: limit }, on: true }, b.v1.as_ref(), &b.d, true).is_ok()+}++/// The document as [`save_to`] writes it, with the images it lists outside the document.+struct Body {+ d: Document,+ /// The version 1 form of `d`, written instead of it.+ v1: Option<serde_json::Value>,+ blobs: BTreeMap<String, ImageBlob>,+ /// Images only linked images show (see [`Document::linked_only_images`]).+ linked: std::collections::BTreeSet<String>,+}++/// `doc` as [`save_to`] writes it with `o`: without editing-mode working copies, with placed+/// documents as their art for older versions, and its images taken out.+fn body(doc: &Document, o: &SaveOptions) -> Result<Body, FormatError> {+ let version = o.version;+ let mut d = doc.without_edit_modes().into_owned();+ // Older apps don't know placed documents: they get the art the objects show, with its+ // resources. Otherwise resources only exporting adds are never saved.+ if version < VERSION && d.has_placed() {+ d = d.with_placed_art().into_owned();+ d.placed_as_groups();+ } else {+ d.drop_placed_resources();+ }+ let linked = d.linked_only_images();+ // The blobs go in the file's `images` (only those the document uses).+ let blobs = std::mem::take(&mut d.images);+ if version < 3 {+ d.store_legacy_color_profiles();+ }+ let v1 = if version == 1 {+ let mut v = serde_json::to_value(&d).map_err(encode_err)?;+ legacy::anchors_to_v1(&mut v);+ Some(v)+ } else {+ None+ };+ Ok(Body { d, v1, blobs, linked })}/// Serialize a document (pretty = human-diffable) in the current version. Editing-mode working@@ -289,9 +337,9 @@ pub fn save(doc: &Document, pretty: bool) -> Vec<u8> {/// compact, where indentation would multiply the file size and slow opening down.pub const PRETTY_MAX_OBJECTS: usize = 2000;-/// Documents whose compact JSON is larger than this are saved compact even with few objects:-/// pretty-printing spreads every path anchor over several lines, so traced or generated art (in-/// layers, symbols or patterns alike) would grow about tenfold.+/// Documents whose pretty-printed JSON is larger than this are saved compact even with few+/// objects: pretty-printing spreads every path anchor over several lines, so traced or generated+/// art (in layers, symbols or patterns alike) grows about fivefold.pub const PRETTY_MAX_BYTES: usize = 1 << 20;/// Serialize for saving to disk: pretty when small, compact when large.@@ -317,28 +365,7 @@ const JSON_CHUNK: usize = 64 << 10;pub fn save_to(doc: &Document, o: &SaveOptions, w: impl Write) -> Result<(), FormatError> {o.check()?;let pretty = o.pretty && !o.compress;- let mut d = doc.without_edit_modes().into_owned();- // Older apps don't know placed documents: they get the art the objects show, with its- // resources. Otherwise resources only exporting adds are never saved.- if o.version < VERSION && d.has_placed() {- d = d.with_placed_art().into_owned();- d.placed_as_groups();- } else {- d.drop_placed_resources();- }- let linked = d.linked_only_images();- // The blobs go in the file's `images` (only those the document uses).- let blobs = std::mem::take(&mut d.images);- if o.version < 3 {- d.store_legacy_color_profiles();- }- let v1 = if o.version == 1 {- let mut v = serde_json::to_value(&d).map_err(encode_err)?;- legacy::anchors_to_v1(&mut v);- Some(v)- } else {- None- };+ let Body { d, v1, blobs, linked } = body(doc, o)?;let entries = Entries { blobs: &blobs, linked: &linked, include_linked: o.include_linked };let mut out_blobs = Blobs { tail: vec![], at: 0, outside: o.version >= 4 };// Images are only referenced by image objects' `key` (wherever the objects are: layers,diff --git a/crates/format/tests/it/save_options.rs b/crates/format/tests/it/save_options.rsindex 41b91a9c5..5cafcb114 100644--- a/crates/format/tests/it/save_options.rs+++ b/crates/format/tests/it/save_options.rs@@ -127,10 +127,70 @@ fn few_objects_with_many_anchors_are_saved_compact() {assert_eq!(load(&bytes).unwrap().layers[0].count(), d.layers[0].count());}+/// Anchors per path that make a document of `paths` paths about `bytes` of pretty-printed JSON.+fn pretty_anchors_for(paths: usize, bytes: usize) -> usize {+ let per_anchor = serde_json::to_vec_pretty(&paths_doc(1, 1000)).unwrap().len() / 1000;+ bytes / per_anchor / paths+}+#[test]fn documents_under_the_size_limit_stay_pretty() {- let d = paths_doc(2, anchors_for(2, PRETTY_MAX_BYTES / 2));+ let d = paths_doc(2, pretty_anchors_for(2, PRETTY_MAX_BYTES / 2));assert!(SaveOptions::for_doc(&d).pretty);+ assert!(is_pretty(&save_file(&d)));+}++#[test]+fn the_limit_is_on_the_pretty_printed_size() {+ // One traced-sized path: well under the limit as compact JSON, over it pretty-printed.+ let d = paths_doc(1, 20_000);+ let compact = serde_json::to_vec(&d).unwrap().len();+ let pretty = serde_json::to_vec_pretty(&d).unwrap().len();+ assert!(compact < PRETTY_MAX_BYTES && pretty > PRETTY_MAX_BYTES, "compact {compact} bytes, pretty {pretty} bytes");+ assert!(!SaveOptions::for_doc(&d).pretty);+ let bytes = save_file(&d);+ assert!(!is_pretty(&bytes));+ assert_eq!(load(&bytes).unwrap().layers[0].count(), d.layers[0].count());+}++#[test]+fn the_files_indentation_counts_toward_the_limit() {+ // The pretty JSON's size and line breaks; the file indents every line after the first by two spaces more.+ let measure = |anchors: usize| {+ let json = serde_json::to_vec_pretty(&paths_doc(1, anchors)).unwrap();+ (json.len(), json.iter().filter(|&&b| b == b'\n').count())+ };+ // The most anchors for which `fits` holds (it holds for 1 and not past twice the estimate).+ let most = |fits: &dyn Fn((usize, usize)) -> bool| {+ let (mut lo, mut hi) = (1, 2 * pretty_anchors_for(1, PRETTY_MAX_BYTES));+ while lo < hi {+ let mid = (lo + hi).div_ceil(2);+ if fits(measure(mid)) { lo = mid } else { hi = mid - 1 }+ }+ lo+ };+ // Without the file's indentation this many anchors fit the limit, with it they do not.+ let bare = most(&|(len, _)| len <= PRETTY_MAX_BYTES);+ let (len, newlines) = measure(bare);+ assert!(len + 2 * newlines > PRETTY_MAX_BYTES, "{len} bytes, {newlines} line breaks");+ assert!(!SaveOptions::for_doc(&paths_doc(1, bare)).pretty);+ // Indented, this many fit.+ let indented = most(&|(len, newlines)| len + 2 * newlines <= PRETTY_MAX_BYTES);+ assert!(indented < bare);+ assert!(SaveOptions::for_doc(&paths_doc(1, indented)).pretty);+ assert!(!SaveOptions::for_doc(&paths_doc(1, indented + 1)).pretty);+}++#[test]+fn the_limit_is_on_the_version_written() {+ // Version 1 writes every anchor with both handles as `{x, y}` maps: this document fits in the+ // current version and not in version 1.+ let d = paths_doc(1, pretty_anchors_for(1, PRETTY_MAX_BYTES / 2));+ let v1 = SaveOptions { version: 1, ..SaveOptions::default() };+ assert!(SaveOptions::default().pretty_fits(&d));+ assert!(!v1.pretty_fits(&d));+ let pretty = save_with(&d, &SaveOptions { pretty: true, ..v1.clone() }).unwrap();+ assert!(pretty.len() > PRETTY_MAX_BYTES, "{} bytes", pretty.len());}#[test]diff --git a/docs/mcp.md b/docs/mcp.mdindex 375f0f7c0..b7f9663d9 100644--- a/docs/mcp.md+++ b/docs/mcp.md@@ -580,6 +580,8 @@ their content). `version: 2` or `1` writes a file older VectorCraft versions opecompressed), and `preview: true` embeds a PNG of the first artboard, at most 256 px on its longer side. A save writesa temporary file and renames it over the old one, so a failed save never damages the file; only the images thedocument uses are written, and document keys written by a newer version are kept.+An uncompressed file is indented JSON when the document has at most 2,000 layers and objects and the indented+document, as the chosen version writes it, is at most 1 MiB; otherwise the file is compact JSON.## Resources