fix(parser): accept the range of unicode in xref/image/inline etc

This is probably too permissive of a set but let's see if anyone complains. If I need to
tighten this up I'll use a specialised function, rather than just pushing a range.

Fixes #438.

Author: nlopes

acdc-parser/CHANGELOG.md

@@ -167,6 +167,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Path-based macros now recognize non-ASCII local targets, including cross-references,
+  links, icons, images, audio, and video, matching Asciidoctor.
 - Table cell specifiers now accept the Asciidoctor order with spans or repeats
   before alignment and style. Column styles after spans, and across repeated
   cells, now follow source-cell order.

acdc-parser/src/grammar/document.rs

@@ -5602,9 +5602,11 @@ peg::parser! {
             format!("#{fragment}")
         }
 
-        /// Filesystem path - conservative character set for cross-platform compatibility
-        /// Includes '{' and '}' for `AsciiDoc` attribute substitution
-        pub rule path() -> String = path:$(['A'..='Z' | 'a'..='z' | '0'..='9' | '{' | '}' | '_' | '-' | '.' | '/' | '\\' ]+)
+        /// Filesystem path accepted by block macros.
+        ///
+        /// ASCII input uses a conservative filename set. Non-ASCII Unicode characters
+        /// are accepted unchanged, and `{`/`}` permit `AsciiDoc` attribute substitution.
+        pub rule path() -> String = path:$(['A'..='Z' | 'a'..='z' | '0'..='9' | '{' | '}' | '_' | '-' | '.' | '/' | '\\' | '\u{80}'..='\u{10FFFF}' ]+)
         {?
             let inline_state = InlinePreprocessorParserState::new_all_enabled(
                 path,

acdc-parser/src/grammar/inlines.rs

@@ -2304,9 +2304,11 @@ peg::parser! {
             Cow::Owned(format!("#{fragment}"))
         }
 
-        /// Filesystem path - conservative character set for cross-platform compatibility
-        /// Includes '{' and '}' for `AsciiDoc` attribute substitution
-        pub rule path() -> Cow<'input, str> = path:$(['A'..='Z' | 'a'..='z' | '0'..='9' | '{' | '}' | '_' | '-' | '.' | '/' | '\\' ]+)
+        /// Filesystem path accepted by inline macros.
+        ///
+        /// ASCII input uses a conservative filename set. Non-ASCII Unicode characters
+        /// are accepted unchanged, and `{`/`}` permit `AsciiDoc` attribute substitution.
+        pub rule path() -> Cow<'input, str> = path:$(['A'..='Z' | 'a'..='z' | '0'..='9' | '{' | '}' | '_' | '-' | '.' | '/' | '\\' | '\u{80}'..='\u{10FFFF}' ]+)
         {?
             let inline_state = InlinePreprocessorParserState::new_all_enabled(
                 path,

acdc-parser/tests/unicode_macro_paths.rs

@@ -0,0 +1,98 @@
+use acdc_parser::{Block, InlineMacro, InlineNode, Options, parse, parse_inline};
+
+type TestResult = Result<(), Box<dyn std::error::Error>>;
+
+fn unexpected(message: &str, actual: impl std::fmt::Debug) -> Box<dyn std::error::Error> {
+    std::io::Error::other(format!("{message}, got {actual:?}")).into()
+}
+
+fn assert_plain_text(text: &[InlineNode<'_>], expected: &str) -> TestResult {
+    let [InlineNode::PlainText(text)] = text else {
+        return Err(unexpected("expected plain macro text", text));
+    };
+    assert_eq!(text.content, expected);
+    Ok(())
+}
+
+#[test]
+fn xref_accepts_non_ascii_path_characters() -> TestResult {
+    for (input, target, text) in [
+        (
+            "xref:die_straße.adoc[my street]",
+            "die_straße.adoc",
+            "my street",
+        ),
+        (
+            "xref:die_straße.adoc#section[street section]",
+            "die_straße.adoc#section",
+            "street section",
+        ),
+    ] {
+        let parsed = parse_inline(input, &Options::default())?;
+        let [InlineNode::Macro(InlineMacro::CrossReference(xref))] = parsed.inlines() else {
+            return Err(unexpected(
+                "expected one cross-reference macro",
+                parsed.inlines(),
+            ));
+        };
+
+        assert_eq!(xref.target, target);
+        assert_plain_text(&xref.text, text)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn other_inline_macros_accept_non_ascii_path_characters() -> TestResult {
+    let parsed = parse_inline("link:die_straße.adoc[street]", &Options::default())?;
+    let [InlineNode::Macro(InlineMacro::Link(link))] = parsed.inlines() else {
+        return Err(unexpected("expected one link macro", parsed.inlines()));
+    };
+    assert_eq!(link.target.to_string(), "die_straße.adoc");
+
+    let parsed = parse_inline("image:straße.png[street]", &Options::default())?;
+    let [InlineNode::Macro(InlineMacro::Image(image))] = parsed.inlines() else {
+        return Err(unexpected(
+            "expected one inline image macro",
+            parsed.inlines(),
+        ));
+    };
+    assert_eq!(image.source.to_string(), "straße.png");
+
+    let parsed = parse_inline("icon:straße[]", &Options::default())?;
+    let [InlineNode::Macro(InlineMacro::Icon(icon))] = parsed.inlines() else {
+        return Err(unexpected("expected one icon macro", parsed.inlines()));
+    };
+    assert_eq!(icon.target.to_string(), "straße");
+
+    Ok(())
+}
+
+#[test]
+fn block_media_macros_accept_non_ascii_path_characters() -> TestResult {
+    let parsed = parse(
+        "image::straße.png[]\n\naudio::straße.mp3[]\n\nvideo::straße.mp4[]\n",
+        &Options::default(),
+    )?;
+    let [
+        Block::Image(image),
+        Block::Audio(audio),
+        Block::Video(video),
+    ] = parsed.document().blocks.as_slice()
+    else {
+        return Err(unexpected(
+            "expected image, audio, and video blocks",
+            &parsed.document().blocks,
+        ));
+    };
+
+    assert_eq!(image.source.to_string(), "straße.png");
+    assert_eq!(audio.source.to_string(), "straße.mp3");
+    let [video_source] = video.sources.as_slice() else {
+        return Err(unexpected("expected one video source", &video.sources));
+    };
+    assert_eq!(video_source.to_string(), "straße.mp4");
+
+    Ok(())
+}