fix codeblock content split across Text events

Fixes: #1

Author: codedstructure

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+- Fixed: handle fenced code block split across Text events (#1)
+
 ## [0.8.0 2025-06-29]
 
 - Changed: updated to svgdx 0.21.0

src/lib.rs

@@ -59,37 +59,12 @@ impl Preprocessor for SvgdxProc {
     }
 }
 
-fn inject_xml(events: &mut Vec<Event>, content: &str) {
-    events.push(Html(
-        "\n\n<div style='overflow-x: auto; font-size: 0.9em;'>\n".into(),
-    ));
-    events.push(Start(Tag::CodeBlock(CodeBlockKind::Fenced("xml".into()))));
-    events.push(Text(content.to_owned().into()));
-    events.push(End(TagEnd::CodeBlock));
-    events.push(Html("\n</div>\n".into()));
-}
-
-fn inject_svgdx(events: &mut Vec<Event>, content: &str) {
-    events.push(Start(Tag::Paragraph));
-    // Need to avoid blank lines in the rendered SVG, as they can cause
-    // markdown to resume 'normal' md processing, especially when e.g.
-    // indentation can cause an implicit code block to be started.
-    // See https://talk.commonmark.org/t/inline-html-breaks-when-using-indentation/3317
-    // and https://spec.commonmark.org/0.31.2/#html-blocks
-    let svg_output = svgdx_handler(content)
-        .lines()
-        .filter(|line| !line.trim().is_empty())
-        .collect::<Vec<_>>()
-        .join("\n");
-    events.push(Html(svg_output.into()));
-    events.push(End(TagEnd::Paragraph));
-}
-
 fn codeblock_parser(chapter: &mut Chapter) -> Result<String, std::fmt::Error> {
     let md_events = mdbook::utils::new_cmark_parser(&chapter.content, false);
 
     let mut in_block = None;
     let mut events = Vec::new();
+    let mut block_content = Vec::new();
     for ev in md_events {
         match (&mut in_block, ev.clone()) {
             (None, Start(Tag::CodeBlock(Fenced(Borrowed(block_type)))))
@@ -108,31 +83,73 @@ fn codeblock_parser(chapter: &mut Chapter) -> Result<String, std::fmt::Error> {
                 ));
                 in_block = Some(block_type.to_string());
             }
-            (Some(block_type), Text(content)) => {
-                if block_type.starts_with("xml-svgdx") {
-                    // Special case this fence type to display the XML input
-                    // prior to the rendered SVG output.
-                    inject_xml(&mut events, &content);
-                }
-                inject_svgdx(&mut events, &content);
-                if block_type.starts_with("svgdx-xml") {
-                    // Special case this fence type to display the XML input
-                    // prior to the rendered SVG output.
-                    inject_xml(&mut events, &content);
-                }
+            (Some(_), Text(content)) => {
+                // content of code block isn't necessarily in a single Text event;
+                // CRLF sources in particular seem to generate a Text event per line.
+                block_content.push(content.clone());
             }
-            (Some(_), End(TagEnd::CodeBlock)) => {
+            (Some(block_type), End(TagEnd::CodeBlock)) => {
+                handle_content(&block_content.concat(), block_type, &mut events);
                 events.push(Html("</div>".into()));
+                block_content.clear();
                 in_block = None;
             }
             _ => events.push(ev),
         }
     }
+    if let Some(block_type) = in_block {
+        // The CommonMark spec allows for non-terminated code blocks, treating
+        // the end of the document as an implicit end-of-fence.
+        // https://spec.commonmark.org/0.31.2/#fenced-code-blocks
+        handle_content(&block_content.concat(), &block_type, &mut events);
+        events.push(Html("</div>".into()));
+    }
+
     let mut buf = String::new();
     cmark(&mut events.iter(), &mut buf)?;
     Ok(buf)
 }
 
+fn handle_content(content: &str, block_type: &str, events: &mut Vec<Event>) {
+    if block_type.starts_with("xml-svgdx") {
+        // Special case this fence type to display the XML input
+        // prior to the rendered SVG output.
+        inject_xml(events, content);
+    }
+    inject_svgdx(events, content);
+    if block_type.starts_with("svgdx-xml") {
+        // Special case this fence type to display the XML input
+        // prior to the rendered SVG output.
+        inject_xml(events, content);
+    }
+}
+
+fn inject_xml(events: &mut Vec<Event>, content: &str) {
+    events.push(Html(
+        "\n\n<div style='overflow-x: auto; font-size: 0.9em;'>\n".into(),
+    ));
+    events.push(Start(Tag::CodeBlock(CodeBlockKind::Fenced("xml".into()))));
+    events.push(Text(content.to_owned().into()));
+    events.push(End(TagEnd::CodeBlock));
+    events.push(Html("\n</div>\n".into()));
+}
+
+fn inject_svgdx(events: &mut Vec<Event>, content: &str) {
+    events.push(Start(Tag::Paragraph));
+    // Need to avoid blank lines in the rendered SVG, as they can cause
+    // markdown to resume 'normal' md processing, especially when e.g.
+    // indentation can cause an implicit code block to be started.
+    // See https://talk.commonmark.org/t/inline-html-breaks-when-using-indentation/3317
+    // and https://spec.commonmark.org/0.31.2/#html-blocks
+    let svg_output = svgdx_handler(content)
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+        .collect::<Vec<_>>()
+        .join("\n");
+    events.push(Html(svg_output.into()));
+    events.push(End(TagEnd::Paragraph));
+}
+
 fn svgdx_handler(s: &str) -> String {
     let cfg = svgdx::TransformConfig {
         svg_style: Some("min-width: 25%; max-width: 100%; height: auto;".to_string()),
@@ -185,4 +202,40 @@ Some **markdown** text
         let mut z = Book::new();
         z.push_item(chapter);
     }
+
+    #[test]
+    fn process_with_crlf() {
+        // crlf-separated text seems to be parsed into multiple Text events;
+        // check the fenced code block is still processed as a single unit.
+        let content = vec![
+            "Some **markdown** text",
+            "",
+            "```svgdx",
+            "<svg>",
+            r#"  <rect wh="20 5"/>"#,
+            r#"  <rect xy="^|h" wh="20 5"/>"#,
+            "</svg>",
+            "```",
+        ]
+        .join("\r\n");
+
+        let expected1 = r##"Some **markdown** text
+
+<div style="##;
+        let expected2 = r##" class='svgdx'>
+
+
+<svg "##;
+        let expected3 = r##"
+  <rect x="20" y="0" width="20" height="5"/>
+</svg></div>"##;
+        let mut chapter = Chapter::new("test", content.to_owned(), ".", Vec::new());
+        let result = codeblock_parser(&mut chapter).unwrap();
+        assert_contains!(result, expected1);
+        assert_contains!(result, expected2);
+        assert_contains!(result, expected3);
+
+        let mut z = Book::new();
+        z.push_item(chapter);
+    }
 }