SVG: a confined Preserve Editing attachment leaves out an Export for Screens folder outside the read roots

Under automation read roots, the native document that an SVG or SVGZ
carries with Preserve Editing now leaves out the Export for Screens
folder (`export_settings.folder`) when that folder is outside the read
roots, as `document.exportSettings` already does in its reply. The other
export settings and the art are kept, a folder inside the roots is kept,
and the open document is not changed.
This commit is contained in:
dotCooCoo
2026-11-15 12:37:42 -08:00
parent bb218101c9
commit a91a3c0fd5
5 changed files with 76 additions and 2 deletions
+1 -1
View File
@@ -764,7 +764,7 @@ fn leave_out_folder(r: &mut Value, folder: &str) {
/// Export settings kept in the document or a preset, as the request being served may see them: a
/// `folder` outside the read roots ([`super::access::shown`]) is left out.
fn leave_out_unreadable_settings_folder(mut settings: Map<String, Value>) -> Map<String, Value> {
pub(super) fn leave_out_unreadable_settings_folder(mut settings: Map<String, Value>) -> Map<String, Value> {
if settings.get("folder").and_then(Value::as_str).is_some_and(|f| !f.is_empty() && !super::access::shown(f)) {
settings.remove("folder");
}
+13 -1
View File
@@ -180,12 +180,24 @@ pub(super) fn lost_artboards_warning(doc: &Document, p: &Value, label: &str) ->
})
}
/// The native document Preserve Editing embeds: `doc`, without an Export for Screens `folder`
/// outside the read roots of the request being served (the open document keeps it).
fn native_attachment(doc: &Document) -> Vec<u8> {
let settings = super::screens::leave_out_unreadable_settings_folder(doc.export_settings.clone());
if settings.len() == doc.export_settings.len() {
return vectorcraft_format::save(doc, false);
}
let mut kept = doc.clone();
kept.export_settings = settings;
vectorcraft_format::save(&kept, false)
}
/// Encode `doc` as SVG (or gzipped, SVGZ): one file per chosen artboard, with the images they
/// link to and the writer's warnings.
pub(super) fn encode(doc: &Document, p: &Value, compressed: bool) -> Result<Encoded, String> {
let (opts, boards, chosen) = plan(doc, p)?;
// Preserve editing embeds the native document (once, shared by every file).
let native = opts.preserve_editing.then(|| vectorcraft_format::save(doc, false));
let native = opts.preserve_editing.then(|| native_attachment(doc));
// Draw linked files as vectors when available, or their previews with a warning. Keep
// that preparation out of the native attachment so missing links remain relinkable.
let (full, warnings) = crate::cmd::place::document::full_documents(doc);
+58
View File
@@ -2138,3 +2138,61 @@ fn confined_preserve_editing_svg_refuses_a_brush_library_entry_it_cannot_read()
confine(roots.as_ref(), || s.execute("document.serialize", &json!({"format": "svg"}))).unwrap();
}
}
/// A confined caller's SVG and SVGZ with Preserve Editing Capabilities carry a native document
/// without the Export for Screens folder when it is outside the read roots, with the other export
/// settings and the art; the open document keeps the folder. A folder inside the roots, and any
/// folder without roots, stays in the attachment.
#[test]
fn confined_preserve_editing_svg_leaves_out_an_export_folder_outside_the_read_roots() {
use crate::file_access::{AutomationRoots, confine};
let away = Folder::new("svg-export-folder-away");
let home = Folder::new("svg-export-folder-home");
let outside = away.0.to_string_lossy().into_owned();
let inside = home.file("screens");
let mut s = session();
let r = s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
let rect: vectorcraft_doc::NodeId = serde_json::from_value(r["id"].clone()).unwrap();
let set_folder = |s: &mut Session, folder: &str| {
let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
doc.export_settings = serde_json::from_value(json!({"folder": folder, "prefix": "web-"})).unwrap();
};
let roots = AutomationRoots::new(&[home.0.as_path()], &[home.0.as_path()]).unwrap();
// The native document an SVG's text carries.
let attached = |text: &str| {
let data = vectorcraft_svg::editing_data(text).expect("editing data");
vectorcraft_format::load(&vectorcraft_format::base64_decode(&data).unwrap()).unwrap()
};
let check = |d: &Document, folder: Option<&str>, what: &str| {
assert_eq!(d.export_settings.get("folder").and_then(Value::as_str), folder, "{what}");
assert_eq!(d.export_settings.get("prefix").and_then(Value::as_str), Some("web-"), "{what}");
assert!(d.node(rect).is_some(), "{what}: no art");
};
// Every way an SVG is asked for with Preserve Editing, its text and its native document.
let every = |s: &mut Session, confined: bool, folder: Option<&str>| {
let run = |s: &mut Session, cmd: &str, p: Value| {
let r = if confined { confine(roots.as_ref(), || s.execute(cmd, &p)) } else { s.execute(cmd, &p) };
r.unwrap()
};
for format in ["svg", "svgz"] {
let r = run(s, "document.serialize", json!({"format": format, "preserveEditing": true}));
check(&attached(&svg_text(&r)), folder, &format!("{format} serialize"));
let r = run(s, "document.serialize", json!({"format": format, "svg": {"preserveEditing": true}}));
check(&attached(&svg_text(&r)), folder, &format!("{format} options object"));
let path = home.file(&format!("export.{format}"));
run(s, "document.export", json!({"format": format, "path": path, "preserveEditing": true}));
let bytes = std::fs::read(&path).unwrap();
check(&attached(&vectorcraft_svg::text_of(&bytes).unwrap()), folder, &format!("{format} export"));
}
};
set_folder(&mut s, &outside);
every(&mut s, true, None);
assert_eq!(s.doc().unwrap().doc.export_settings.get("folder").and_then(Value::as_str), Some(outside.as_str()));
every(&mut s, false, Some(&outside));
// Without Preserve Editing the SVG carries no native document.
let r = confine(roots.as_ref(), || s.execute("document.serialize", &json!({"format": "svg"}))).unwrap();
assert!(vectorcraft_svg::editing_data(&svg_text(&r)).is_none(), "{r}");
set_folder(&mut s, &inside);
every(&mut s, true, Some(&inside));
}
+3
View File
@@ -261,6 +261,9 @@ the suite) keep the agent to the folders you give it:
selected objects only, and `clipboard.exportSvg` checks the copied objects, following a relative path from
the document they came from while it is open; in a frame a request drives, Copy then puts no SVG on the
system clipboard. An image whose pixels the document holds exports embedded, and a URL is not checked.
- With `preserveEditing`, the document an SVG or SVGZ of these outputs carries leaves out the Export for Screens
folder (`export_settings.folder`) when it is outside the read roots, as `document.exportSettings` does; the
other export settings and the art are kept, and the open document keeps the folder.
- `plugin.list`, `plugin.safeMode`, `file.recovery.*` and `ui_inspect`'s `scriptReport` leave out the paths
outside the read roots, also those the person or an earlier request put there. In `plugin.list`, the plug-in
folder last loaded is `null` in `folder.folder`, and a failed file in `folder.failed` and a plug-in's `source`
+1
View File
@@ -878,6 +878,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- Document replies under `--automation-read-root`: `document.inspect` gives `path` as null for a document file outside the read roots, and `document.json` names a linked image or placed file outside them by its file name alone, without its relative path, size or date, brush art included, leaves out a relative path that leads outside them and a stored brush entry that does not read as a brush, names a data set's image value outside them by its file name, and leaves an Export for Screens folder outside them out of `export_settings`; the document is not changed. `crates/engine/src/tests/placed_document.rs` (`document_replies_leave_out_paths_outside_the_read_roots`, `document_json_checks_brush_art_and_relative_paths_against_the_read_roots`).
- SVG output under `--automation-read-root`: `document.serialize`, `document.export`, `document.exportSelection`, `document.exportForScreens`, `assets.export`, the SVG and SVGZ saves, `file.exportAs` and the SVG Options dialog's Show Code refuse an SVG or SVGZ of a document that links a JavaScript file outside the read roots, before any file or folder is written, with an error that names no file or folder; a URL, a file inside the roots and a relative path that leads inside them are written as stored, and the person at the keyboard exports every link as stored. `crates/engine/src/tests/interactivity.rs` (`confined_svg_output_refuses_a_linked_javascript_file_outside_the_read_roots`, `svg_output_keeps_linked_javascript_files_a_caller_may_read`), `crates/ui-egui/src/tests/automation.rs` (`control_svg_export_refuses_a_linked_javascript_file_outside_the_read_root`), `crates/ui-egui/src/dialogs/svg_options.rs` (`show_code_leaves_out_a_linked_javascript_file_outside_the_read_roots`).
- Linked images in SVG output under `--automation-read-root`: the same outputs, and `clipboard.exportSvg`, refuse an SVG or SVGZ that would name a linked image's file outside the read roots (`images: link`, an image whose pixels the document doesn't hold, or `preserveEditing`), before any file or folder is written, with an error that names no file or folder; Copy in a frame a request drives then puts no SVG on the system clipboard. Embedded pixels, a file inside the roots, a relative path that leads inside them and a URL are written as before, and the person at the keyboard exports every link as stored. `crates/engine/src/tests/links.rs` (`confined_svg_output_refuses_a_linked_image_file_outside_the_read_roots`, `svg_output_names_linked_image_files_a_caller_may_read`, `confined_clipboard_svg_refuses_a_linked_image_file_outside_the_read_roots`, `confined_preserve_editing_svg_refuses_a_brush_library_entry_it_cannot_read`, `confined_svg_output_checks_only_the_linked_images_it_writes`, `confined_svg_output_writes_a_colorized_gray_image_without_its_file`), `crates/ui-egui/src/tests/automation.rs` (`control_svg_export_refuses_a_linked_image_file_outside_the_read_root`), `crates/ui-egui/src/dialogs/svg_options.rs` (`show_code_leaves_out_a_linked_image_file_outside_the_read_roots`).
- Preserve Editing SVG under `--automation-read-root`: the native document an SVG or SVGZ carries leaves out an Export for Screens folder outside the read roots, and keeps the other export settings and the art; the open document keeps the folder, and a folder inside the roots is kept. `crates/engine/src/tests/links.rs` (`confined_preserve_editing_svg_leaves_out_an_export_folder_outside_the_read_roots`).
- Linked-file and font-file searches under `--automation-read-root`: `links.findFiles` and `text.findFontFiles` replies, also later polls and stops of a search another client started, leave out the files found, a link's saved path and the folder searched outside the caller's read roots, and a failed search gives its reason without the path; `image.info` gives `link: null` for a linked file outside them; `text.addFontFiles` gives `folder: null` and the copies' file names when the Fonts folder is outside them. `crates/engine/src/tests/linkfiles.rs`, `crates/engine/src/tests/fontfiles.rs`, `crates/engine/tests/font_folder.rs`.
- Swatch, brush, symbol and graphic style library lists under `--automation-read-root`: every library stays listed, the paths of library files and the user library folder outside the read roots are `null`, a library loaded from outside them is listed and found as `loaded/<file name>` and keeps that id for the session unless a library loaded later without a file shows that id itself, which moves it to the next free `loaded/<file name> (N)`, and the app's own list is not changed. `crates/engine/src/tests/library_roots.rs`.
- Preferences commands under `--automation-read-root`: `prefs.get`, `prefs.list`, `prefs.set` and `prefs.reset` show folder preferences outside the read roots as `null` and leave out an export preset's folder outside them, and the preferences are not changed. `crates/engine/src/tests/prefs_roots.rs`.