From 6882c6da4a4cde99644a28ee38b1e26b3934f955 Mon Sep 17 00:00:00 2001 From: bchanot Date: Thu, 15 Oct 2026 01:00:44 +0200 Subject: [PATCH] feat(anatomy): an unnamed trigger carries the opened view's name per language --- crates/core/src/anatomy/layer.rs | 66 +++++++++++++++++++------- crates/core/tests/anatomy_canvas_op.rs | 15 +++--- crates/core/tests/anatomy_compose.rs | 19 ++++++-- crates/core/tests/anatomy_layer.rs | 55 ++++++++++++++++++++- crates/core/tests/common/svg_tree.rs | 42 ++++++++++++++++ 5 files changed, 168 insertions(+), 29 deletions(-) diff --git a/crates/core/src/anatomy/layer.rs b/crates/core/src/anatomy/layer.rs index c3f29b2a..407efeb1 100644 --- a/crates/core/src/anatomy/layer.rs +++ b/crates/core/src/anatomy/layer.rs @@ -5,7 +5,9 @@ use std::collections::{HashMap, HashSet}; use super::svg::{Element, Node}; -use crate::domain::sheet::{AnatomicalSheetDocument, Annotation, Geometry, Laterality, SheetView}; +use crate::domain::sheet::{ + AnatomicalSheetDocument, Annotation, Geometry, Laterality, LocalizedText, SheetView, +}; use crate::json::js_number; pub const FALLBACK_COLOR: &str = "#888888"; @@ -39,11 +41,7 @@ pub fn render_layer( .iter() .map(|c| (c.id.as_str(), c.color.as_deref())) .collect(), - view_names: document - .views - .iter() - .map(|v| (v.id(), v.name().fr.as_str())) - .collect(), + view_names: document.views.iter().map(|v| (v.id(), v.name())).collect(), states, }; let children = document @@ -64,7 +62,7 @@ struct Context<'a> { twin_opacity: &'static str, /// Last duplicate wins, as a JavaScript `Map` built from the list. categories: HashMap<&'a str, Option<&'a str>>, - view_names: HashMap<&'a str, &'a str>, + view_names: HashMap<&'a str, &'a LocalizedText>, states: &'a HashSet<&'a str>, } @@ -107,18 +105,14 @@ impl Context<'_> { let mut data: Attrs = vec![("data-anno-id", annotation.id().to_owned())]; match annotation { Annotation::DetailTrigger(t) => { - let opened = self - .view_names - .get(t.opens_view_id.as_str()) - .copied() - .unwrap_or(""); + let opened = self.view_names.get(t.opens_view_id.as_str()).copied(); data.push(("data-anno-kind", "detail_trigger".to_owned())); data.push(("data-anno-lateral", laterality(t.laterality).to_owned())); data.push(("data-anno-opens-view", t.opens_view_id.clone())); - let names = t - .name - .as_ref() - .map_or((opened, opened), |n| (n.fr.as_str(), n.en.as_str())); + let names = match &t.name { + Some(n) => (n.fr.as_str(), n.en.as_str()), + None => opened.map_or(("", ""), localized_names), + }; data.push(("data-anno-name-fr", names.0.to_owned())); data.push(("data-anno-name-en", names.1.to_owned())); } @@ -182,6 +176,23 @@ impl Context<'_> { } } +/// A trigger without a name of its own takes the opened view's name in each language +/// (owner decision 2026-10-15; until R3 both attributes carried the French name). A language +/// left empty falls back to the other one. +fn localized_names(name: &LocalizedText) -> (&str, &str) { + let fr = if name.fr.is_empty() { + &name.en + } else { + &name.fr + }; + let en = if name.en.is_empty() { + &name.fr + } else { + &name.en + }; + (fr, en) +} + fn value_of<'a>(attrs: &'a Attrs, name: &str) -> &'a str { attrs .iter() @@ -268,3 +279,26 @@ pub fn view_box_of(view: &SheetView) -> Option { ) }) } + +#[cfg(test)] +mod tests { + use super::*; + + fn text(fr: &str, en: &str) -> LocalizedText { + LocalizedText { + fr: fr.to_owned(), + en: en.to_owned(), + } + } + + #[test] + fn an_unnamed_trigger_takes_the_opened_view_name_in_each_language() { + assert_eq!(localized_names(&text("Tête", "Head")), ("Tête", "Head")); + } + + #[test] + fn a_missing_language_falls_back_to_the_other() { + assert_eq!(localized_names(&text("Tête", "")), ("Tête", "Tête")); + assert_eq!(localized_names(&text("", "Head")), ("Head", "Head")); + } +} diff --git a/crates/core/tests/anatomy_canvas_op.rs b/crates/core/tests/anatomy_canvas_op.rs index 6cdf6a75..b6549d07 100644 --- a/crates/core/tests/anatomy_canvas_op.rs +++ b/crates/core/tests/anatomy_canvas_op.rs @@ -4,7 +4,7 @@ mod common; -use common::svg_tree::tree_value; +use common::svg_tree::{tree_value, view_names, with_trigger_names_per_language}; use faunosteo_core::anatomy::svg::tree::parse_svg; use faunosteo_core::domain::js::parse_json; use faunosteo_core::domain::sheet::{BundledSheetData, LoadedSheet}; @@ -33,11 +33,12 @@ fn call(sheet: &LoadedSheet, input: Value) -> Value { serde_json::from_str(&call_with_sheet(sheet, "view.canvas", &input.to_string())).unwrap() } -fn golden(name: &str) -> Value { - serde_json::from_str(&common::repo_file(&format!( - "apps/app/tests/fixtures/goldens/r3/{name}" - ))) - .unwrap() +/// A frozen canvas golden with the declared trigger-name change applied. +fn golden(name: &str, sheet: &LoadedSheet) -> Value { + let text = common::repo_file(&format!("apps/app/tests/fixtures/goldens/r3/{name}")); + let mut frozen: Value = serde_json::from_str(&text).unwrap(); + with_trigger_names_per_language(&mut frozen, &view_names(&sheet.document)); + frozen } #[test] @@ -49,7 +50,7 @@ fn each_view_answers_the_frozen_canvas() { let svg = out["value"]["svg"].as_str().unwrap(); assert_eq!( tree_value(&parse_svg(svg).unwrap()), - golden(&format!("canvas.{view}.json")), + golden(&format!("canvas.{view}.json"), &sheet), "{view}" ); } diff --git a/crates/core/tests/anatomy_compose.rs b/crates/core/tests/anatomy_compose.rs index 1922f3e9..1ca69e8d 100644 --- a/crates/core/tests/anatomy_compose.rs +++ b/crates/core/tests/anatomy_compose.rs @@ -11,7 +11,7 @@ mod common; use std::collections::HashSet; -use common::svg_tree::{reread, tree_value}; +use common::svg_tree::{reread, tree_value, view_names, with_trigger_names_per_language}; use faunosteo_core::anatomy::compose::{asset_id_of_view, compose_canvas, compose_highlight}; use faunosteo_core::anatomy::layer::render_layer; use faunosteo_core::anatomy::svg::{Element, read_svg}; @@ -90,13 +90,18 @@ fn every_highlighted_view_equals_the_engine_tree() { .is_main(); let composed = compose_highlight(document, view, asset, &ids, main).unwrap(); let label = format!("{} {} {view}", case["sheet"], case["observation"]["id"]); - assert_eq!(reread(&composed), expected(case, &oracle), "{label}"); + let mut frozen = expected(case, &oracle); + with_trigger_names_per_language(&mut frozen, &view_names(document)); + assert_eq!(reread(&composed), frozen, "{label}"); } } +/// A frozen canvas golden with the declared trigger-name change applied (draft views). fn canvas_golden(name: &str) -> Value { let text = common::repo_file(&format!("apps/app/tests/fixtures/goldens/r3/{name}")); - serde_json::from_str(&text).unwrap() + let mut frozen: Value = serde_json::from_str(&text).unwrap(); + with_trigger_names_per_language(&mut frozen, &view_names(&draft())); + frozen } #[test] @@ -110,8 +115,14 @@ fn every_canvas_equals_the_frozen_tree_and_every_state_set_its_layer() { canvas_golden(&format!("canvas.{view}.json")), "{view}" ); - let layers = canvas_golden(&format!("canvas.{view}.layers.json")); + let layers: Value = serde_json::from_str(&common::repo_file(&format!( + "apps/app/tests/fixtures/goldens/r3/canvas.{view}.layers.json" + ))) + .unwrap(); for (name, frozen) in layers.as_object().unwrap() { + let mut frozen = frozen.clone(); + with_trigger_names_per_language(&mut frozen, &view_names(&draft)); + let frozen = &frozen; let states = frozen_states(frozen); let ids: HashSet<&str> = states.iter().map(String::as_str).collect(); let layer = render_layer(&draft, view, &ids).unwrap(); diff --git a/crates/core/tests/anatomy_layer.rs b/crates/core/tests/anatomy_layer.rs index 35b341b9..b2308457 100644 --- a/crates/core/tests/anatomy_layer.rs +++ b/crates/core/tests/anatomy_layer.rs @@ -7,6 +7,7 @@ mod common; use std::collections::HashSet; +use common::svg_tree::{view_names, with_trigger_names_per_language}; use faunosteo_core::anatomy::layer::render_layer; use faunosteo_core::anatomy::svg::{Element, Node}; use faunosteo_core::domain::sheet::AnatomicalSheetDocument; @@ -73,10 +74,12 @@ fn every_frozen_layer_is_reproduced_with_its_attribute_order() { .collect(); let layer = layer_value(&render_layer(document, view, &states).unwrap()); let label = format!("{} {} {:?}", case["doc"], view, states.len()); - assert_eq!(layer, case["layer"], "{label}"); + let mut frozen = case["layer"].clone(); + with_trigger_names_per_language(&mut frozen, &view_names(document)); + assert_eq!(layer, frozen, "{label}"); let (mut ours, mut theirs) = (Vec::new(), Vec::new()); orders(&layer, &mut ours); - orders(&case["layer"], &mut theirs); + orders(&frozen, &mut theirs); assert_eq!(ours, theirs, "{label}: attribute order"); } } @@ -87,3 +90,51 @@ fn an_unknown_view_is_refused() { let edge = AnatomicalSheetDocument::deserialize(&oracle["edge"]).unwrap(); assert!(render_layer(&edge, "nope", &HashSet::new()).is_err()); } + +#[test] +fn an_unnamed_trigger_names_the_opened_view_in_each_language_and_a_named_one_keeps_its_names() { + let (_, draft) = common::oracle_file("sheet.draft.json"); + let draft = AnatomicalSheetDocument::deserialize(&draft["output"]).unwrap(); + let layer = render_layer(&draft, "main", &HashSet::new()).unwrap(); + let trigger = layer + .element_children() + .find(|e| e.attr("data-anno-id") == Some("head-trigger")) + .unwrap(); + assert_eq!( + trigger.attr("data-anno-name-fr"), + Some("Tête (vue latérale gauche)") + ); + assert_eq!( + trigger.attr("data-anno-name-en"), + Some("Head (left lateral view)") + ); + let title = trigger.element_children().next().unwrap(); + assert_eq!( + title.children, + [Node::Text( + "Tête (vue latérale gauche) / Head (left lateral view)".to_owned() + )] + ); + // The edge document: an unnamed trigger on a view named Tête / Head, a named one. + let (_, oracle) = common::oracle_file("r3/layer.json"); + let edge = AnatomicalSheetDocument::deserialize(&oracle["edge"]).unwrap(); + let layer = render_layer(&edge, "main", &HashSet::new()).unwrap(); + let names = |id: &str| { + let e = layer + .element_children() + .find(|e| e.attr("data-anno-id") == Some(id)) + .unwrap(); + ( + e.attr("data-anno-name-fr").unwrap().to_owned(), + e.attr("data-anno-name-en").unwrap().to_owned(), + ) + }; + assert_eq!( + names("trigger-circle"), + ("Tête".to_owned(), "Head".to_owned()) + ); + assert_eq!( + names("trigger-named"), + ("Ouvrir".to_owned(), "Open".to_owned()) + ); +} diff --git a/crates/core/tests/common/svg_tree.rs b/crates/core/tests/common/svg_tree.rs index 72c3b2eb..03075b9b 100644 --- a/crates/core/tests/common/svg_tree.rs +++ b/crates/core/tests/common/svg_tree.rs @@ -35,3 +35,45 @@ pub fn tree_value(element: &Element) -> Value { pub fn reread(element: &Element) -> Value { tree_value(&parse_svg(&serialize(element)).unwrap()) } + +/// Owner decision 2026-10-15 (R3): a trigger without a name of its own carries the opened +/// view's name in each language (the TypeScript freeze carries the French name twice). The +/// frozen trees stay as frozen; this declared change is applied to them before comparing: +/// `data-anno-name-en` takes the view's English name and the title reads "FR / EN". +pub fn with_trigger_names_per_language(tree: &mut Value, views: &[(String, String, String)]) { + if let Some(attrs) = tree.get_mut("attrs").and_then(Value::as_object_mut) { + let opened = attrs + .get("data-anno-opens-view") + .and_then(Value::as_str) + .map(str::to_owned); + let view = opened.and_then(|id| views.iter().find(|(v, _, _)| *v == id)); + if let Some((_, fr, en)) = view + && attrs.get("data-anno-name-en").and_then(Value::as_str) == Some(fr.as_str()) + { + attrs.insert("data-anno-name-en".to_owned(), Value::String(en.clone())); + } + } + if let Some(text) = tree.get_mut("text") { + for (_, fr, en) in views { + if text.as_str() == Some(format!("{fr} / {fr}").as_str()) { + *text = Value::String(format!("{fr} / {en}")); + } + } + } + if let Some(children) = tree.get_mut("children").and_then(Value::as_array_mut) { + for child in children { + with_trigger_names_per_language(child, views); + } + } +} + +/// (view id, FR name, EN name) of a document, for `with_trigger_names_per_language`. +pub fn view_names( + document: &faunosteo_core::domain::sheet::AnatomicalSheetDocument, +) -> Vec<(String, String, String)> { + document + .views + .iter() + .map(|v| (v.id().to_owned(), v.name().fr.clone(), v.name().en.clone())) + .collect() +}