Refuse local references to ids a drawing does not define, scope canvas ids per view, upload every drawing in one stored form checked by the verdict and the preview, keep strict numeric rgb() colours, and commit real Inkscape 1.4.3 exports with their generator.
277 lines
11 KiB
Rust
277 lines
11 KiB
Rust
//! V1-2.2 owner decision 2026-10-29: SVG references and the isolation of views. A local
|
|
//! reference to an id the drawing does not define is refused by the reader, the cleaning, the
|
|
//! verdict and the preview; the canvas, inlined in the page, scopes every id and reference to
|
|
//! its view, so two drawings with the same ids never resolve into each other and a valid
|
|
//! reference keeps working; the composition is deterministic.
|
|
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use faunosteo_core::anatomy::svg::clean::{CleaningOutcome, clean_svg};
|
|
use faunosteo_core::anatomy::svg::sanitize::{local_reference_text, url_targets};
|
|
use faunosteo_core::anatomy::svg::tree::parse_svg;
|
|
use faunosteo_core::anatomy::svg::{Element, SvgRejection, read_svg};
|
|
use faunosteo_core::domain::sheet::preview::{
|
|
PreviewDrawing, PreviewDrawingStatus, PreviewInput, PreviewSheet, PreviewStatus,
|
|
};
|
|
use faunosteo_core::domain::sheet::verdict::{
|
|
DrawingResult, VerdictBinding, VerdictDrawing, VerdictInput, codes, compute_verdict, sha256_hex,
|
|
};
|
|
use faunosteo_core::facade::call_with_preview;
|
|
use serde_json::{Value, json};
|
|
|
|
const MAIN_ASSET: &str = "11111111-2222-4333-8444-555555555555";
|
|
const DETAIL_ASSET: &str = "66666666-7777-4888-9999-aaaaaaaaaaaa";
|
|
/// The opening of a drawing in its stored form (prolog, then the root as the core writes it).
|
|
const OPEN: &str = concat!(
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",
|
|
r#"<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 10 10">"#
|
|
);
|
|
|
|
/// Valid references, one id named several times, by `href`, `xlink:href` and `url(…)`.
|
|
fn main_drawing() -> String {
|
|
format!(
|
|
"{OPEN}<defs><linearGradient id=\"g\"/><g id=\"big\"><path d=\"M0 0h1\"/></g></defs>\
|
|
<path fill=\"url(#g)\" d=\"M0 0h2\"/><use href=\"#big\"/><use xlink:href=\"#big\"/>\
|
|
<path stroke=\"url( '#g')\" style=\"fill:url(#g)\" d=\"M0 0h3\"/></svg>"
|
|
)
|
|
}
|
|
|
|
/// The same ids as the main drawing, with other content.
|
|
fn detail_drawing() -> String {
|
|
format!(
|
|
"{OPEN}<defs><radialGradient id=\"g\"/></defs><circle id=\"big\" r=\"1\"/>\
|
|
<path fill=\"url(#g)\" d=\"M0 0h4\"/><use href=\"#big\"/></svg>"
|
|
)
|
|
}
|
|
|
|
/// A detail drawing naming the main drawing's group, which it does not define.
|
|
fn cross_view_drawing() -> String {
|
|
format!("{OPEN}{}</svg>", "<use href=\"#big\"/>".repeat(256))
|
|
}
|
|
|
|
fn name(text: &str) -> Value {
|
|
json!({ "fr": text, "en": text })
|
|
}
|
|
|
|
fn document() -> String {
|
|
json!({
|
|
"schema_version": 2, "species_id": "canine", "name": name("Chien"),
|
|
"description": {}, "scope_disclaimer": { "fr": "Outil", "en": "Tool" },
|
|
"attribution": { "authors": ["A"], "license": null, "notes": null },
|
|
"vertebral_config": { "regions": [] }, "references": [],
|
|
"categories": [{ "id": "c", "name": name("C"), "color": null }],
|
|
"views": [
|
|
{ "id": "main", "kind": "main", "name": name("Vue"), "svg_asset_id": MAIN_ASSET, "view_box": null },
|
|
{ "id": "detail", "kind": "detail", "name": name("Tête"), "svg_asset_id": DETAIL_ASSET,
|
|
"view_box": null, "parent_view_id": "main" }
|
|
],
|
|
"annotations": [], "finding_zones": []
|
|
})
|
|
.to_string()
|
|
}
|
|
|
|
fn drawing(asset_id: &str, text: &str) -> PreviewDrawing {
|
|
PreviewDrawing {
|
|
asset_id: asset_id.to_owned(),
|
|
sha256: sha256_hex(text.as_bytes()),
|
|
bytes: text.as_bytes().to_vec(),
|
|
}
|
|
}
|
|
|
|
fn preview(detail: &str) -> PreviewSheet {
|
|
let input = PreviewInput {
|
|
status: PreviewStatus::Draft,
|
|
document: document(),
|
|
fingerprint: None,
|
|
};
|
|
let drawings = vec![
|
|
drawing(MAIN_ASSET, &main_drawing()),
|
|
drawing(DETAIL_ASSET, detail),
|
|
];
|
|
PreviewSheet::load(input, drawings).unwrap()
|
|
}
|
|
|
|
fn canvas_outcome(preview: &PreviewSheet, view: &str) -> Value {
|
|
let input = json!({ "viewId": view }).to_string();
|
|
serde_json::from_str(&call_with_preview(preview, "view.canvas", &input)).unwrap()
|
|
}
|
|
|
|
fn canvas(preview: &PreviewSheet, view: &str) -> String {
|
|
let outcome = canvas_outcome(preview, view);
|
|
assert_eq!(outcome["ok"], json!(true), "{outcome}");
|
|
outcome["value"]["svg"].as_str().unwrap().to_owned()
|
|
}
|
|
|
|
/// Ids in document order, and every reference (`href`, `xlink:href`, `url(#…)`).
|
|
fn ids_and_references(element: &Element, ids: &mut Vec<String>, refs: &mut Vec<String>) {
|
|
for attr in &element.attrs {
|
|
match attr.qname.as_str() {
|
|
"id" => ids.push(attr.value.clone()),
|
|
"href" | "xlink:href" => {
|
|
if let Some(id) = local_reference_text(&attr.value).strip_prefix('#') {
|
|
refs.push(id.to_owned());
|
|
}
|
|
}
|
|
_ => refs.extend(url_targets(&attr.value)),
|
|
}
|
|
}
|
|
for child in element.element_children() {
|
|
ids_and_references(child, ids, refs);
|
|
}
|
|
}
|
|
|
|
fn parsed(text: &str) -> (Vec<String>, Vec<String>) {
|
|
let (mut ids, mut refs) = (Vec::new(), Vec::new());
|
|
ids_and_references(&parse_svg(text).unwrap(), &mut ids, &mut refs);
|
|
(ids, refs)
|
|
}
|
|
|
|
#[test]
|
|
fn a_valid_local_reference_keeps_working_inside_its_view() {
|
|
let preview = preview(&detail_drawing());
|
|
let main = canvas(&preview, "main");
|
|
let (ids, refs) = parsed(&main);
|
|
assert!(ids.iter().all(|id| id.starts_with("fv.main.")), "{ids:?}");
|
|
assert!(!refs.is_empty());
|
|
for reference in &refs {
|
|
assert!(
|
|
ids.contains(reference),
|
|
"{reference} resolves in its canvas"
|
|
);
|
|
}
|
|
// The canvas reads back through the one reader: no reference dangles, none cycles.
|
|
assert!(read_svg(&main).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn several_references_to_one_id_all_name_its_scoped_id() {
|
|
let main = canvas(&preview(&detail_drawing()), "main");
|
|
let (_, refs) = parsed(&main);
|
|
let count = |id: &str| refs.iter().filter(|r| r.as_str() == id).count();
|
|
assert_eq!(count("fv.main.big"), 2);
|
|
assert_eq!(count("fv.main.g"), 3);
|
|
assert_eq!(refs.len(), 5);
|
|
assert!(main.contains("url( '#fv.main.g')") && main.contains("fill:url(#fv.main.g)"));
|
|
}
|
|
|
|
#[test]
|
|
fn a_reference_to_an_absent_id_is_refused_everywhere() {
|
|
let dangling = format!("{OPEN}<path id=\"p\" fill=\"url(#missing)\"/><use href=\"#p\"/></svg>");
|
|
assert_eq!(
|
|
read_svg(&dangling).err(),
|
|
Some(SvgRejection::DanglingReference)
|
|
);
|
|
let cleaning = clean_svg(dangling.as_bytes());
|
|
assert_eq!(cleaning.outcome, CleaningOutcome::Rejected);
|
|
assert_eq!(cleaning.reason.as_deref(), Some("dangling_reference"));
|
|
assert!(cleaning.preview.is_none() && cleaning.sha256.is_none());
|
|
|
|
// The preview reports the drawing and draws nothing from it; the other view still draws.
|
|
let preview = preview(&dangling);
|
|
let state = preview.state().unwrap();
|
|
let detail = state
|
|
.drawings
|
|
.iter()
|
|
.find(|d| d.asset_id == DETAIL_ASSET)
|
|
.unwrap();
|
|
assert_eq!(detail.state, PreviewDrawingStatus::Rejected);
|
|
assert_eq!(detail.detail.as_deref(), Some("dangling_reference"));
|
|
let refused = canvas_outcome(&preview, "detail");
|
|
assert_eq!(
|
|
(refused["kind"].as_str(), refused["detail"].as_str()),
|
|
(Some("svg_rejected"), Some("dangling_reference"))
|
|
);
|
|
canvas(&preview, "main");
|
|
|
|
// The verdict refuses the stored drawing.
|
|
let main = main_drawing();
|
|
let document = document();
|
|
let row = |asset_id: &'static str, text: &str| VerdictDrawing {
|
|
asset_id,
|
|
sha256: Box::leak(sha256_hex(text.as_bytes()).into_boxed_str()),
|
|
byte_size: text.len() as u64,
|
|
bytes: Some(Box::leak(text.as_bytes().to_vec().into_boxed_slice())),
|
|
};
|
|
let verdict = compute_verdict(&VerdictInput {
|
|
binding: VerdictBinding {
|
|
sheet_id: "s".to_owned(),
|
|
version_id: "v".to_owned(),
|
|
revision: 1,
|
|
review_id: "r".to_owned(),
|
|
},
|
|
document: &document,
|
|
base_document: None,
|
|
drawings: vec![row(MAIN_ASSET, &main), row(DETAIL_ASSET, &dangling)],
|
|
});
|
|
assert!(verdict.failures.iter().any(|f| f == codes::SVG_REJECTED));
|
|
let checked = verdict
|
|
.drawings
|
|
.iter()
|
|
.find(|d| d.asset_id == DETAIL_ASSET)
|
|
.unwrap();
|
|
assert_eq!(checked.result, DrawingResult::SvgRejected);
|
|
assert_eq!(checked.detail.as_deref(), Some("dangling_reference"));
|
|
}
|
|
|
|
#[test]
|
|
fn a_view_cannot_name_an_element_of_another_view() {
|
|
let cross = cross_view_drawing();
|
|
assert_eq!(
|
|
read_svg(&cross).err(),
|
|
Some(SvgRejection::DanglingReference)
|
|
);
|
|
assert_eq!(
|
|
clean_svg(cross.as_bytes()).reason.as_deref(),
|
|
Some("dangling_reference")
|
|
);
|
|
let refused = canvas_outcome(&preview(&cross), "detail");
|
|
assert_eq!(refused["detail"], json!("dangling_reference"));
|
|
}
|
|
|
|
#[test]
|
|
fn identical_ids_in_two_views_resolve_each_in_its_own_view() {
|
|
let preview = preview(&detail_drawing());
|
|
let canvases = [canvas(&preview, "main"), canvas(&preview, "detail")];
|
|
// The page as a browser reads it: both canvases inlined, `#id` naming the first element
|
|
// with that id in document order.
|
|
let mut first_owner: HashMap<String, usize> = HashMap::new();
|
|
let mut references: Vec<(usize, String)> = Vec::new();
|
|
for (index, text) in canvases.iter().enumerate() {
|
|
let (ids, refs) = parsed(text);
|
|
for id in ids {
|
|
first_owner.entry(id).or_insert(index);
|
|
}
|
|
references.extend(refs.into_iter().map(|r| (index, r)));
|
|
}
|
|
assert!(references.iter().any(|(i, _)| *i == 1));
|
|
for (index, reference) in &references {
|
|
assert_eq!(first_owner.get(reference), Some(index), "{reference}");
|
|
}
|
|
let (main_ids, _) = parsed(&canvases[0]);
|
|
let (detail_ids, _) = parsed(&canvases[1]);
|
|
assert!(main_ids.iter().all(|id| !detail_ids.contains(id)));
|
|
assert!(detail_ids.contains(&"fv.detail.g".to_owned()));
|
|
}
|
|
|
|
#[test]
|
|
fn composition_is_deterministic_and_repeatable() {
|
|
let preview = preview(&detail_drawing());
|
|
let first = (canvas(&preview, "main"), canvas(&preview, "detail"));
|
|
let again = (canvas(&preview, "detail"), canvas(&preview, "main"));
|
|
assert_eq!(first, (again.1, again.0));
|
|
let other = self::preview(&detail_drawing());
|
|
assert_eq!(canvas(&other, "main"), first.0);
|
|
// Scoping is applied once per composition, never compounded.
|
|
assert!(!first.0.contains("fv.main.fv.main."));
|
|
// The stored bytes are not touched: the drawing still hashes to its row.
|
|
let state = preview.state().unwrap();
|
|
assert!(
|
|
state
|
|
.drawings
|
|
.iter()
|
|
.all(|d| d.state == PreviewDrawingStatus::Ok)
|
|
);
|
|
assert_eq!(preview.drawing_reads(), 2);
|
|
}
|