fix ampersand in node labels splitting nodes incorrectly

smitbarmase · smitbarmase · commit 374db9ead542 · 2026-03-02T18:06:42.000+05:30
diff --git a/src/lib.rs b/src/lib.rs
@@ -388,4 +388,38 @@ mod tests {
         assert!(svg.contains("Dogs"));
         assert!(!svg.contains("Syntax error in text"));
     }
+
+    #[test]
+    fn test_ampersand_in_node_labels_renders_valid_svg() {
+        let svg = render(
+            r#"flowchart LR
+A["Agent reads artifacts & computes deps"] --> B["List & select changes"]"#,
+        )
+        .unwrap();
+        assert!(svg.contains("<svg"));
+        assert!(svg.contains("</svg>"));
+        // The `&` should be XML-escaped to `&amp;` in the SVG output
+        assert!(
+            svg.contains("&amp;"),
+            "SVG should contain XML-escaped ampersand"
+        );
+        // The label text may be wrapped across <tspan> elements, so check
+        // that the escaped ampersand appears in the rendered text content.
+        assert!(
+            svg.contains("artifacts &amp;") || svg.contains("artifacts &amp; computes"),
+            "Source label should contain escaped ampersand near 'artifacts'"
+        );
+        assert!(
+            svg.contains("List &amp; select"),
+            "Target label should be intact with escaped ampersand"
+        );
+        // Verify both nodes exist (not split into phantom nodes)
+        // The SVG should have exactly 2 rectangle shapes for the 2 nodes
+        let rect_count = svg.matches("<rect").count();
+        // background rect + 2 node rects = 3
+        assert!(
+            rect_count >= 3,
+            "Expected at least 3 rects (1 bg + 2 nodes), got {rect_count}"
+        );
+    }
 }
diff --git a/src/parser.rs b/src/parser.rs
@@ -363,21 +363,34 @@ fn parse_flowchart(input: &str) -> Result<ParseOutput> {
     Ok(ParseOutput { graph, init_config })
 }
 
+/// Split on `&` that is outside brackets, parens, braces, and quotes.
+fn split_ampersand_aware(input: &str) -> Vec<&str> {
+    let masked = mask_bracket_content(input);
+    let mut parts = Vec::new();
+    let mut start = 0;
+    for (i, ch) in masked.char_indices() {
+        if ch == '&' {
+            let part = input[start..i].trim();
+            if !part.is_empty() {
+                parts.push(part);
+            }
+            start = i + 1;
+        }
+    }
+    let last = input[start..].trim();
+    if !last.is_empty() {
+        parts.push(last);
+    }
+    parts
+}
+
 fn add_flowchart_edge(line: &str, graph: &mut Graph, subgraph_stack: &[usize]) -> bool {
     let Some((left, label, right, edge_meta)) = parse_edge_line(line) else {
         return false;
     };
 
-    let sources: Vec<&str> = left
-        .split('&')
-        .map(|part| part.trim())
-        .filter(|part| !part.is_empty())
-        .collect();
-    let targets: Vec<&str> = right
-        .split('&')
-        .map(|part| part.trim())
-        .filter(|part| !part.is_empty())
-        .collect();
+    let sources = split_ampersand_aware(&left);
+    let targets = split_ampersand_aware(&right);
 
     let mut source_ids = Vec::new();
     for source in sources {
@@ -3589,16 +3602,8 @@ fn parse_block_diagram(input: &str) -> Result<ParseOutput> {
             continue;
         }
         if let Some((left, label, right, edge_meta)) = parse_edge_line(line) {
-            let sources: Vec<&str> = left
-                .split('&')
-                .map(|part| part.trim())
-                .filter(|part| !part.is_empty())
-                .collect();
-            let targets: Vec<&str> = right
-                .split('&')
-                .map(|part| part.trim())
-                .filter(|part| !part.is_empty())
-                .collect();
+            let sources = split_ampersand_aware(&left);
+            let targets = split_ampersand_aware(&right);
 
             for source in &sources {
                 let (source_id, source_label, source_shape, source_classes) =
@@ -6054,6 +6059,46 @@ mod tests {
         assert!(parsed.graph.nodes.contains_key("C"));
     }
 
+    #[test]
+    fn parse_ampersand_in_source_label() {
+        let input = r#"flowchart LR
+A["Agent reads artifacts & computes deps"] --> B"#;
+        let parsed = parse_mermaid(input).unwrap();
+        assert_eq!(parsed.graph.edges.len(), 1);
+        assert_eq!(parsed.graph.nodes.len(), 2);
+        assert!(parsed.graph.nodes.contains_key("A"));
+        assert!(parsed.graph.nodes.contains_key("B"));
+        assert_eq!(
+            parsed.graph.nodes["A"].label,
+            "Agent reads artifacts & computes deps"
+        );
+    }
+
+    #[test]
+    fn parse_ampersand_in_target_label() {
+        let input = r#"flowchart LR
+A --> B["List & select changes"]"#;
+        let parsed = parse_mermaid(input).unwrap();
+        assert_eq!(parsed.graph.edges.len(), 1);
+        assert_eq!(parsed.graph.nodes.len(), 2);
+        assert!(parsed.graph.nodes.contains_key("A"));
+        assert!(parsed.graph.nodes.contains_key("B"));
+        assert_eq!(parsed.graph.nodes["B"].label, "List & select changes");
+    }
+
+    #[test]
+    fn parse_parallel_ampersand_with_label_ampersand() {
+        let input = r#"flowchart LR
+A["foo & bar"] & B --> C"#;
+        let parsed = parse_mermaid(input).unwrap();
+        assert_eq!(parsed.graph.edges.len(), 2);
+        assert_eq!(parsed.graph.nodes.len(), 3);
+        assert!(parsed.graph.nodes.contains_key("A"));
+        assert!(parsed.graph.nodes.contains_key("B"));
+        assert!(parsed.graph.nodes.contains_key("C"));
+        assert_eq!(parsed.graph.nodes["A"].label, "foo & bar");
+    }
+
     #[test]
     fn parse_subgraph_style() {
         let input = "flowchart LR\nclassDef hot fill:#f00,stroke:#0f0\nsubgraph SG[Group]:::hot\nA --> B\nend\nclass SG hot\nstyle SG fill:#faf,stroke:#111";
