From 12b5ba75fb5d9e8864c10a21d129baa2dd5aad71 Mon Sep 17 00:00:00 2001 From: mavrick Date: Tue, 10 Nov 2026 02:18:40 -0600 Subject: [PATCH 1/4] fix(engine): update typed references when a layer is renamed Carry map-local and unambiguous project references with the new name. Keep ambiguous references unchanged and report their count. --- crates/engine/src/cmd/layer.rs | 115 +++++++++++++++++++++++++ crates/engine/src/tests.rs | 152 +++++++++++++++++++++++++++++++++ 2 files changed, 267 insertions(+) diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs index b56af5908c..0520820c4b 100644 --- a/crates/engine/src/cmd/layer.rs +++ b/crates/engine/src/cmd/layer.rs @@ -101,6 +101,7 @@ pub fn commands() -> Vec { } // So do legends that leave it out. legends_follow_layer(s, &old, Some(&n)); + references_follow_layer(s, &old, &n); Ok(r) }).roles(&[]).effects(crate::policy::Effects::NONE).params(r#"{"layer"?, "name": string}"#) .when(need_layer), @@ -4712,6 +4713,120 @@ pub(crate) fn legends_follow_layer(s: &mut Session, old: &str, new: Option<&str> } } +/// Carries typed references to a renamed layer along with it. Map-local references and layout +/// frames stay in their map. A name still present there keeps its references, as legends do; +/// project-wide references without a map stay unchanged when another map still has that name. +/// Script text, tool parameters and history are not rewritten. +fn references_follow_layer(s: &mut Session, old: &str, new: &str) { + use rustgis_map::design::{Elevation, TopologyRule}; + use rustgis_map::layout::ElementKind; + + if s.map().layers.iter().any(|l| l.name.eq_ignore_ascii_case(old)) { + return; + } + let collision = s.map().layers.iter().filter(|l| l.name.eq_ignore_ascii_case(new)).count() > 1; + let mut collision_left = 0usize; + let mut replace = |name: &mut String| { + if name.eq_ignore_ascii_case(old) { + if collision { + collision_left += 1; + } else { + *name = new.to_string(); + } + } + }; + let map_name = s.map().name.clone(); + let editing = &mut s.map_mut().editing; + for relation in &mut editing.relationships { + replace(&mut relation.origin); + replace(&mut relation.destination); + } + for rule in &mut editing.topology { + match rule { + TopologyRule::MustNotOverlap { layer } + | TopologyRule::MustNotHaveGaps { layer } + | TopologyRule::MustNotSelfIntersect { layer } + | TopologyRule::MustNotHaveDangles { layer } => replace(layer), + TopologyRule::MustBeCoveredBy { layer, by } => { + replace(layer); + replace(by); + } + } + } + if let Elevation::Surface(layer) = &mut editing.settings.elevation { + replace(layer); + } + for layout in &mut s.project.layouts { + let frames: Vec = layout + .elements + .iter() + .filter_map(|e| match &e.kind { + ElementKind::MapFrame { map, .. } if map.eq_ignore_ascii_case(&map_name) => Some(e.id), + _ => None, + }) + .collect(); + for element in &mut layout.elements { + match &mut element.kind { + ElementKind::Table { frame, layer, .. } | ElementKind::Chart { frame, layer, .. } if frames.contains(frame) => { + replace(layer) + } + ElementKind::Colorbar { frame, layer: Some(layer), .. } if frames.contains(frame) => replace(layer), + _ => {} + } + } + if let Some(series) = &mut layout.series + && frames.contains(&series.frame) + { + replace(&mut series.layer); + } + } + // These items do not record a map; changing an ambiguous name would redirect references + // used with another map. Keep those spellings until the user chooses their intended layer. + let shared = s + .project + .maps + .iter() + .enumerate() + .any(|(i, map)| i != s.project.active_map && map.layers.iter().any(|layer| layer.name.eq_ignore_ascii_case(old))); + let mut left = 0usize; + let mut project_reference = |name: &mut String| { + if shared && name.eq_ignore_ascii_case(old) { + left += 1; + } else { + replace(name); + } + }; + for report in &mut s.project.reports { + project_reference(&mut report.layer); + } + for model in &mut s.project.models { + if let Some(graph) = &mut model.graph { + for node in &mut graph.nodes { + if let Some(layer) = &mut node.layer { + project_reference(layer); + } + } + } + } + for workspace in &mut s.project.workspaces { + for image in &mut workspace.images { + project_reference(image); + } + } + if left > 0 { + s.notify_text(crate::notice_text::NoticeText::format( + "{count} project reference(s) still name '{old}': another map has a layer of that name; choose the intended layer in those items", + [("count", left.to_string().into()), ("old", old.to_string().into())], + ), false); + } + if collision_left > 0 { + s.notify_text(crate::notice_text::NoticeText::format( + "{count} layer reference(s) still name '{old}': two layers are now called '{new}'; give the layer a unique name and choose it in those items", + [("count", collision_left.to_string().into()), ("old", old.to_string().into()), ("new", new.to_string().into())], + ), false); + } +} + /// Removes the layers `ids` from the active map, and legends that left them out forget them, as /// `layer.remove` does. Paths that delete several layers at once go through here. pub(crate) fn drop_layers(s: &mut Session, ids: &[u32]) { diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index f13184a141..f40c9abf54 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -24828,6 +24828,158 @@ fn map_rename_names_any_map_and_what_shows_it_follows() { assert_eq!(s.map().name, "Second"); } +/// Compares all project state except the geometry cache revision invalidated by undo. +fn renamed_project_state(s: &Session) -> Value { + let mut value = serde_json::to_value(&s.project).unwrap(); + for map in value["maps"].as_array_mut().unwrap() { + for layer in map["layers"].as_array_mut().unwrap() { + layer.as_object_mut().unwrap().remove("geometry_rev"); + } + } + value +} + +/// Everything a project keeps that names a layer follows the layer's rename, as the map frames +/// follow a map's. +#[test] +fn what_names_a_layer_follows_its_rename() { + /// Collects reference spellings from each typed item's JSON without depending on its shape. + fn strings(v: &Value, out: &mut Vec) { + match v { + Value::String(t) => out.push(t.clone()), + Value::Array(a) => a.iter().for_each(|v| strings(v, out)), + Value::Object(o) => o.values().for_each(|v| strings(v, out)), + _ => {} + } + } + let mut s = world(); + s.run("layer.addDataBytes", &json!({"fileName": "dem.tif", "data": dem_b64()})).unwrap(); + s.run("layout.new", &json!({"page": "a4"})).unwrap(); + let li = s.active_layout.unwrap(); + let mut elements = vec![("legend exclude", s.project.layouts[li].elements.iter().find(|e| e.name == "Legend").unwrap().id)]; + s.run("layout.update", &json!({"element": elements[0].1, "exclude": ["Countries"]})).unwrap(); + for (what, el) in [ + ("layout table", json!({"kind": "table", "layer": "Countries"})), + ("layout chart", json!({"kind": "chart", "layer": "Countries", "field": "pop_est", "label": "name"})), + ("layout colorbar", json!({"kind": "colorbar", "layer": "dem"})), + ] { + let id = s.run("layout.addElement", &el).unwrap()["element"].as_u64().unwrap() as u32; + elements.push((what, id)); + } + s.run("layout.series", &json!({"layer": "Countries", "nameField": "name"})).unwrap(); + s.run("layer.mask", &json!({"layer": "Cities", "mask": "Countries"})).unwrap(); + s.run("map.terrain", &json!({"layer": "dem"})).unwrap(); + s.run("report.new", &json!({"layer": "Countries", "name": "Report", "fields": ["name"]})).unwrap(); + let graph = json!({ + "nodes": [ + {"id": "i1", "kind": "input", "x": 0, "y": 0, "layer": "Countries"}, + {"id": "o1", "kind": "output", "x": 240, "y": 0, "name": "Kept"} + ], + "edges": [{"from": "i1", "fromPort": "out", "to": "o1", "toPort": "in"}] + }); + s.run("model.new", &json!({"name": "Model", "graph": graph})).unwrap(); + s.run("data.relate", &json!({"name": "Country of city", "origin": "Countries", "originKey": "name", "destination": "Cities", "destinationKey": "adm0name"})) + .unwrap(); + s.run("topology.rules", &json!({"add": {"rule": "mustBeCoveredBy", "layer": "Cities", "by": "Countries"}})).unwrap(); + s.run("edit.elevation", &json!({"mode": "surface", "surface": "dem"})).unwrap(); + s.run("imagery.workspace", &json!({"kind": "reality", "name": "Heights", "images": ["dem"]})).unwrap(); + + let before = renamed_project_state(&s); + s.run("layer.rename", &json!({"layer": "Countries", "name": "Nations"})).unwrap(); + s.run("layer.rename", &json!({"layer": "dem", "name": "Elevation"})).unwrap(); + + let mut refs: Vec<(&str, Value)> = Vec::new(); + for (what, id) in &elements { + let e = s.project.layouts[li].elements.iter().find(|e| e.id == *id).unwrap(); + // A colorbar's title is literal display text, not a layer reference. + let reference = match &e.kind { + rustgis_map::layout::ElementKind::Colorbar { layer, .. } => json!(layer), + _ => serde_json::to_value(&e.kind).unwrap(), + }; + refs.push((what, reference)); + } + let series = s.project.layouts[li].series.as_ref().map(|m| m.layer.clone()); + refs.push(("map series", json!(series))); + refs.push(("mask", json!(s.map().layer_by_name("Cities").unwrap().mask))); + refs.push(("terrain", serde_json::to_value(&s.map().view.terrain).unwrap())); + refs.push(("report", json!(s.project.reports[0].layer))); + let model = s.project.models.iter().find(|m| m.name == "Model").unwrap(); + refs.push(("model input", serde_json::to_value(&model.graph.as_ref().unwrap().nodes[0]).unwrap())); + refs.push(("relationship", serde_json::to_value(&s.map().editing.relationships[0]).unwrap())); + refs.push(("topology rule", serde_json::to_value(&s.map().editing.topology).unwrap())); + refs.push(("edit elevation", serde_json::to_value(&s.map().editing.settings.elevation).unwrap())); + refs.push(("imagery workspace", json!(s.project.workspaces[0].images))); + + let stale: Vec = refs + .iter() + .filter_map(|(what, v)| { + let mut names = Vec::new(); + strings(v, &mut names); + let old = names.iter().find(|n| *n == "Countries" || *n == "dem")?; + Some(format!("{what} still names '{old}'")) + }) + .collect(); + assert!(stale.is_empty(), "{} of {} references kept the old name:\n{}", stale.len(), refs.len(), stale.join("\n")); + s.run("edit.undo", &Value::Null).unwrap(); + s.run("edit.undo", &Value::Null).unwrap(); + assert_eq!(renamed_project_state(&s), before, "undo restores every reference with its layer name"); +} + +/// A layout reference follows only the map its frame shows; a project-wide reference without +/// a map stays put, with a notice, when the old name also exists in a second map. +#[test] +fn layer_rename_keeps_references_in_their_maps() { + use rustgis_map::layout::ElementKind; + let mut s = world(); + s.run("layout.new", &json!({"page": "a4"})).unwrap(); + s.run("layout.addElement", &json!({"kind": "table", "layer": "Countries"})).unwrap(); + s.run("layout.series", &json!({"layer": "Countries", "nameField": "name"})).unwrap(); + s.run("report.new", &json!({"layer": "Countries", "name": "Report", "fields": ["name"]})).unwrap(); + let mut second = s.map().clone(); + second.name = "Second".into(); + s.project.maps.push(second); + let mut second_layout = s.project.layouts[0].clone(); + second_layout.name = "Second layout".into(); + for element in &mut second_layout.elements { + if let ElementKind::MapFrame { map, .. } = &mut element.kind { + *map = "Second".into(); + } + } + s.project.layouts.push(second_layout); + let mark = s.notice_mark(); + s.run("layer.rename", &json!({"layer": "Countries", "name": "Nations"})).unwrap(); + for (layout, expected) in s.project.layouts.iter().zip(["Nations", "Countries"]) { + assert_eq!(layout.series.as_ref().unwrap().layer, expected); + for element in &layout.elements { + if let ElementKind::Table { layer, .. } = &element.kind { + assert_eq!(layer, expected); + } + } + } + assert_eq!(s.project.reports[0].layer, "Countries"); + assert!(s.notices_since(mark).iter().any(|n| n.text.contains("another map has a layer of that name"))); +} + +#[test] +fn layer_rename_never_redirects_a_table_to_another_layer_of_the_new_name() { + use rustgis_map::layout::ElementKind; + let mut s = world(); + let cities = s.map().layer_by_name("Cities").unwrap().id; + s.run("layout.new", &json!({"page": "a4"})).unwrap(); + let id = s.run("layout.addElement", &json!({"kind": "table", "layer": "Cities"})).unwrap()["element"].as_u64().unwrap() as u32; + let before = renamed_project_state(&s); + let mark = s.notice_mark(); + s.run("layer.rename", &json!({"layer": cities, "name": "Countries"})).unwrap(); + let table = s.project.layouts[0].elements.iter().find(|e| e.id == id).unwrap(); + let ElementKind::Table { layer, .. } = &table.kind else { panic!("not a table") }; + assert_eq!(layer, "Cities"); + assert!(s.map().layer_by_name(layer).is_none(), "a stale reference must never display another layer's rows"); + assert!(s.notices_since(mark).iter().any(|n| n.text.contains("two layers are now called 'Countries'"))); + s.run("edit.undo", &Value::Null).unwrap(); + assert_eq!(renamed_project_state(&s), before); + assert_eq!(s.map().layer_by_name("Cities").unwrap().id, cities); +} + #[test] fn layout_elements_are_brought_to_the_front_and_sent_to_the_back() { let mut s = world(); From 6041f0940ffa59dc386d01a8afdbaf108e05acc0 Mon Sep 17 00:00:00 2001 From: mavrick Date: Tue, 10 Nov 2026 06:19:37 -0600 Subject: [PATCH 2/4] fix(engine): report ambiguous layer references after rename Keep project references unchanged when another map has the destination name, and count references retained on a duplicate old name in the active map. --- crates/engine/src/cmd/layer.rs | 26 +++++++++++++------- crates/engine/src/tests.rs | 43 +++++++++++++++++++++++++++++++++- 2 files changed, 59 insertions(+), 10 deletions(-) diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs index 0520820c4b..44fc6d39a2 100644 --- a/crates/engine/src/cmd/layer.rs +++ b/crates/engine/src/cmd/layer.rs @@ -4721,14 +4721,18 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { use rustgis_map::design::{Elevation, TopologyRule}; use rustgis_map::layout::ElementKind; - if s.map().layers.iter().any(|l| l.name.eq_ignore_ascii_case(old)) { + let old_present = s.map().layers.iter().any(|l| l.name.eq_ignore_ascii_case(old)); + if old_present && old.eq_ignore_ascii_case(new) { return; } + let mut old_left = 0usize; let collision = s.map().layers.iter().filter(|l| l.name.eq_ignore_ascii_case(new)).count() > 1; let mut collision_left = 0usize; let mut replace = |name: &mut String| { if name.eq_ignore_ascii_case(old) { - if collision { + if old_present { + old_left += 1; + } else if collision { collision_left += 1; } else { *name = new.to_string(); @@ -4782,12 +4786,10 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { } // These items do not record a map; changing an ambiguous name would redirect references // used with another map. Keep those spellings until the user chooses their intended layer. - let shared = s - .project - .maps - .iter() - .enumerate() - .any(|(i, map)| i != s.project.active_map && map.layers.iter().any(|layer| layer.name.eq_ignore_ascii_case(old))); + let shared = s.project.maps.iter().enumerate().any(|(i, map)| { + i != s.project.active_map + && map.layers.iter().any(|layer| layer.name.eq_ignore_ascii_case(old) || layer.name.eq_ignore_ascii_case(new)) + }); let mut left = 0usize; let mut project_reference = |name: &mut String| { if shared && name.eq_ignore_ascii_case(old) { @@ -4815,10 +4817,16 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { } if left > 0 { s.notify_text(crate::notice_text::NoticeText::format( - "{count} project reference(s) still name '{old}': another map has a layer of that name; choose the intended layer in those items", + "{count} project reference(s) still name '{old}': another map has a layer of the old or new name; choose the intended layer in those items", [("count", left.to_string().into()), ("old", old.to_string().into())], ), false); } + if old_left > 0 { + s.notify_text(crate::notice_text::NoticeText::format( + "{count} layer reference(s) still name '{old}': another layer in this map has that name; choose the intended layer in those items", + [("count", old_left.to_string().into()), ("old", old.to_string().into())], + ), false); + } if collision_left > 0 { s.notify_text(crate::notice_text::NoticeText::format( "{count} layer reference(s) still name '{old}': two layers are now called '{new}'; give the layer a unique name and choose it in those items", diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index f40c9abf54..16e5781179 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -24957,7 +24957,7 @@ fn layer_rename_keeps_references_in_their_maps() { } } assert_eq!(s.project.reports[0].layer, "Countries"); - assert!(s.notices_since(mark).iter().any(|n| n.text.contains("another map has a layer of that name"))); + assert!(s.notices_since(mark).iter().any(|n| n.text.contains("another map has a layer of the old or new name"))); } #[test] @@ -24980,6 +24980,47 @@ fn layer_rename_never_redirects_a_table_to_another_layer_of_the_new_name() { assert_eq!(s.map().layer_by_name("Cities").unwrap().id, cities); } +/// A project-wide report must not begin resolving to a different map after a rename. +#[test] +fn layer_rename_keeps_project_references_when_another_map_has_the_new_name() { + let mut s = world(); + s.run("report.new", &json!({"layer": "Countries", "name": "Report", "fields": ["name"]})).unwrap(); + let mut second = s.map().clone(); + second.name = "Second".into(); + for layer in &mut second.layers { + if layer.name == "Countries" { + layer.name = "Nations".into(); + } + } + s.project.maps.push(second); + let before = renamed_project_state(&s); + let mark = s.notice_mark(); + s.run("layer.rename", &json!({"layer": "Countries", "name": "Nations"})).unwrap(); + assert_eq!(s.project.reports[0].layer, "Countries"); + assert!(s.notices_since(mark).iter().any(|n| n.text.contains("1 project reference(s)") && n.text.contains("old or new name"))); + s.project.active_map = 1; + assert!(s.project.maps.iter().all(|map| map.layer_by_name(&s.project.reports[0].layer).is_none())); + s.project.active_map = 0; + s.run("edit.undo", &Value::Null).unwrap(); + assert_eq!(renamed_project_state(&s), before); +} + +/// References left on a duplicate old name need a notice because the intended layer is unknown. +#[test] +fn layer_rename_says_when_references_keep_a_duplicate_old_name() { + let mut s = world(); + let countries = s.map().layer_by_name("Countries").unwrap().id; + s.run("layout.new", &json!({"page": "a4"})).unwrap(); + let table = s.run("layout.addElement", &json!({"kind": "table", "layer": "Countries"})).unwrap()["element"].as_u64().unwrap() as u32; + s.map_mut().layers.iter_mut().find(|layer| layer.name == "Cities").unwrap().name = "Countries".into(); + let mark = s.notice_mark(); + s.run("layer.rename", &json!({"layer": countries, "name": "Nations"})).unwrap(); + let element = s.project.layouts[0].elements.iter().find(|element| element.id == table).unwrap(); + let rustgis_map::layout::ElementKind::Table { layer, .. } = &element.kind else { panic!("not a table") }; + assert_eq!(layer, "Countries"); + assert!(s.notices_since(mark).iter().any(|n| n.text.contains("1 layer reference(s)") && n.text.contains("another layer in this map"))); +} + #[test] fn layout_elements_are_brought_to_the_front_and_sent_to_the_back() { let mut s = world(); From 9e03e84d59268cc9112a97c279a6c04bbf41c502 Mon Sep 17 00:00:00 2001 From: mavrick Date: Tue, 10 Nov 2026 09:01:59 -0600 Subject: [PATCH 3/4] fix(engine): retain ambiguous layer mask references --- crates/engine/src/cmd/layer.rs | 23 ++++++++++++----------- crates/engine/src/tests.rs | 7 ++++++- 2 files changed, 18 insertions(+), 12 deletions(-) diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs index 44fc6d39a2..1883004312 100644 --- a/crates/engine/src/cmd/layer.rs +++ b/crates/engine/src/cmd/layer.rs @@ -93,12 +93,6 @@ pub fn commands() -> Vec { s.notify(said, false); } } - // Layers masked by this one follow the new name. - for l in &mut s.map_mut().layers { - if l.mask.as_deref().is_some_and(|m| m.eq_ignore_ascii_case(&old)) { - l.mask = Some(n.clone()); - } - } // So do legends that leave it out. legends_follow_layer(s, &old, Some(&n)); references_follow_layer(s, &old, &n); @@ -4721,12 +4715,10 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { use rustgis_map::design::{Elevation, TopologyRule}; use rustgis_map::layout::ElementKind; - let old_present = s.map().layers.iter().any(|l| l.name.eq_ignore_ascii_case(old)); - if old_present && old.eq_ignore_ascii_case(new) { - return; - } + let case_only = old.eq_ignore_ascii_case(new); + let old_present = !case_only && s.map().layers.iter().any(|l| l.name.eq_ignore_ascii_case(old)); let mut old_left = 0usize; - let collision = s.map().layers.iter().filter(|l| l.name.eq_ignore_ascii_case(new)).count() > 1; + let collision = !case_only && s.map().layers.iter().filter(|l| l.name.eq_ignore_ascii_case(new)).count() > 1; let mut collision_left = 0usize; let mut replace = |name: &mut String| { if name.eq_ignore_ascii_case(old) { @@ -4739,6 +4731,15 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { } } }; + for layer in &mut s.map_mut().layers { + if let Some(mask) = &mut layer.mask { + replace(mask); + } + } + // Preserve the existing case-only mask spelling update; other references still resolve. + if case_only { + return; + } let map_name = s.map().name.clone(); let editing = &mut s.map_mut().editing; for relation in &mut editing.relationships { diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 16e5781179..1b1d9aabaa 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -25009,16 +25009,21 @@ fn layer_rename_keeps_project_references_when_another_map_has_the_new_name() { #[test] fn layer_rename_says_when_references_keep_a_duplicate_old_name() { let mut s = world(); + s.run("layer.mask", &json!({"layer": "Rivers", "mask": "Countries"})).unwrap(); let countries = s.map().layer_by_name("Countries").unwrap().id; s.run("layout.new", &json!({"page": "a4"})).unwrap(); let table = s.run("layout.addElement", &json!({"kind": "table", "layer": "Countries"})).unwrap()["element"].as_u64().unwrap() as u32; s.map_mut().layers.iter_mut().find(|layer| layer.name == "Cities").unwrap().name = "Countries".into(); + let before = renamed_project_state(&s); let mark = s.notice_mark(); s.run("layer.rename", &json!({"layer": countries, "name": "Nations"})).unwrap(); let element = s.project.layouts[0].elements.iter().find(|element| element.id == table).unwrap(); let rustgis_map::layout::ElementKind::Table { layer, .. } = &element.kind else { panic!("not a table") }; assert_eq!(layer, "Countries"); - assert!(s.notices_since(mark).iter().any(|n| n.text.contains("1 layer reference(s)") && n.text.contains("another layer in this map"))); + assert_eq!(s.map().layer_by_name("Rivers").unwrap().mask.as_deref(), Some("Countries")); + assert!(s.notices_since(mark).iter().any(|n| n.text.contains("2 layer reference(s)") && n.text.contains("another layer in this map"))); + s.run("edit.undo", &Value::Null).unwrap(); + assert_eq!(renamed_project_state(&s), before); } #[test] From 5d1b4458885a9437829ca13e37604d3a475c3669 Mon Sep 17 00:00:00 2001 From: mavrick Date: Tue, 10 Nov 2026 12:29:23 -0600 Subject: [PATCH 4/4] fix(engine): keep rename selectors current and report destination ambiguity Count references already using a duplicate destination name, and update case-sensitive elevation and map-series selectors on unambiguous case-only renames. --- crates/engine/src/cmd/layer.rs | 38 ++++++++++++++++++++-- crates/engine/src/tests.rs | 59 ++++++++++++++++++++++++++++++++++ 2 files changed, 95 insertions(+), 2 deletions(-) diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs index 1883004312..b8fd46a4f2 100644 --- a/crates/engine/src/cmd/layer.rs +++ b/crates/engine/src/cmd/layer.rs @@ -4720,6 +4720,7 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { let mut old_left = 0usize; let collision = !case_only && s.map().layers.iter().filter(|l| l.name.eq_ignore_ascii_case(new)).count() > 1; let mut collision_left = 0usize; + let mut destination_refs = 0usize; let mut replace = |name: &mut String| { if name.eq_ignore_ascii_case(old) { if old_present { @@ -4729,6 +4730,8 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { } else { *name = new.to_string(); } + } else if collision && name.eq_ignore_ascii_case(new) { + destination_refs += 1; } }; for layer in &mut s.map_mut().layers { @@ -4736,8 +4739,23 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { replace(mask); } } - // Preserve the existing case-only mask spelling update; other references still resolve. + // Elevation and Map Series selectors compare spellings exactly, even though lookup does not. if case_only { + if s.map().layers.iter().filter(|l| l.name.eq_ignore_ascii_case(old)).count() == 1 { + if let Elevation::Surface(layer) = &mut s.map_mut().editing.settings.elevation { + replace(layer); + } + let map_name = s.map().name.clone(); + for layout in &mut s.project.layouts { + if let Some(series) = &mut layout.series + && layout.elements.iter().any(|e| { + e.id == series.frame && matches!(&e.kind, ElementKind::MapFrame { map, .. } if map.eq_ignore_ascii_case(&map_name)) + }) + { + replace(&mut series.layer); + } + } + } return; } let map_name = s.map().name.clone(); @@ -4792,8 +4810,17 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { && map.layers.iter().any(|layer| layer.name.eq_ignore_ascii_case(old) || layer.name.eq_ignore_ascii_case(new)) }); let mut left = 0usize; + let shared_new = s + .project + .maps + .iter() + .enumerate() + .any(|(i, map)| i != s.project.active_map && map.layers.iter().any(|layer| layer.name.eq_ignore_ascii_case(new))); + let mut project_destination_refs = 0usize; let mut project_reference = |name: &mut String| { - if shared && name.eq_ignore_ascii_case(old) { + if shared_new && name.eq_ignore_ascii_case(new) { + project_destination_refs += 1; + } else if shared && name.eq_ignore_ascii_case(old) { left += 1; } else { replace(name); @@ -4834,6 +4861,13 @@ fn references_follow_layer(s: &mut Session, old: &str, new: &str) { [("count", collision_left.to_string().into()), ("old", old.to_string().into()), ("new", new.to_string().into())], ), false); } + let destination_refs = destination_refs + project_destination_refs; + if destination_refs > 0 { + s.notify_text(crate::notice_text::NoticeText::format( + "{count} layer or project reference(s) already name '{new}': the rename created duplicate layer names and may change which layer they use; give the renamed layer a unique name", + [("count", destination_refs.to_string().into()), ("new", new.to_string().into())], + ), false); + } } /// Removes the layers `ids` from the active map, and legends that left them out forget them, as diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 1b1d9aabaa..e3b8365da8 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -24980,6 +24980,65 @@ fn layer_rename_never_redirects_a_table_to_another_layer_of_the_new_name() { assert_eq!(s.map().layer_by_name("Cities").unwrap().id, cities); } +/// Case-only renames keep exact-spelling selectors current without changing other maps. +#[test] +fn layer_rename_keeps_case_sensitive_selectors_current() { + use rustgis_map::design::Elevation; + let mut s = world(); + s.run("layout.new", &json!({"page": "a4"})).unwrap(); + s.run("layout.series", &json!({"layer": "Countries", "nameField": "name"})).unwrap(); + let mut other_layout = s.project.layouts[0].clone(); + for element in &mut other_layout.elements { + if let rustgis_map::layout::ElementKind::MapFrame { map, .. } = &mut element.kind { + *map = "Second".into(); + } + } + s.project.layouts.push(other_layout); + s.map_mut().editing.settings.elevation = Elevation::Surface("Countries".into()); + let before = renamed_project_state(&s); + let mark = s.notice_mark(); + s.run("layer.rename", &json!({"layer": "Countries", "name": "countries"})).unwrap(); + assert_eq!(s.map().editing.settings.elevation, Elevation::Surface("countries".into())); + assert_eq!(s.project.layouts[0].series.as_ref().unwrap().layer, "countries"); + assert_eq!(s.project.layouts[1].series.as_ref().unwrap().layer, "Countries"); + assert!(s.notices_since(mark).is_empty()); + s.run("edit.undo", &Value::Null).unwrap(); + assert_eq!(renamed_project_state(&s), before); +} + +/// References already using the destination name need a notice when lookup becomes ambiguous. +#[test] +fn layer_rename_reports_references_already_using_a_duplicate_destination() { + for other_map in [false, true] { + let mut s = world(); + let (layer, new, expected) = if other_map { + let mut second = s.map().clone(); + second.name = "Second".into(); + second.layers.iter_mut().find(|l| l.name == "Countries").unwrap().name = "Nations".into(); + s.project.maps.push(second); + ("Countries", "Nations", 1) + } else { + s.run("layer.mask", &json!({"layer": "Rivers", "mask": "Countries"})).unwrap(); + s.run("layout.new", &json!({"page": "a4"})).unwrap(); + s.run("layout.addElement", &json!({"kind": "table", "layer": "Countries"})).unwrap(); + ("Cities", "Countries", 3) + }; + s.run("report.new", &json!({"layer": new, "name": "Report", "fields": ["name"]})).unwrap(); + let before = renamed_project_state(&s); + let mark = s.notice_mark(); + s.run("layer.rename", &json!({"layer": layer, "name": new})).unwrap(); + let notices: Vec<_> = s.notices_since(mark).iter().filter(|n| n.text.contains("already name")).collect(); + assert_eq!(notices.len(), 1); + assert!(notices[0].text.starts_with(&format!("{expected} layer or project reference(s)")), "{}", notices[0].text); + assert_eq!(s.project.reports[0].layer, new); + s.run("edit.undo", &Value::Null).unwrap(); + assert_eq!(renamed_project_state(&s), before); + let mark = s.notice_mark(); + s.run("layer.rename", &json!({"layer": layer, "name": "Unique Name"})).unwrap(); + assert!(s.notices_since(mark).iter().all(|n| !n.text.contains("already name"))); + } +} + /// A project-wide report must not begin resolving to a different map after a rename. #[test] fn layer_rename_keeps_project_references_when_another_map_has_the_new_name() {