mod: broken link reference callback gets normalized and original.

Fixes #143.

src/lib.rs

@@ -100,9 +100,10 @@ pub use html::format_document as format_html;
 pub use html::format_document_with_plugins as format_html_with_plugins;
 pub use html::Anchorizer;
 pub use parser::{
-    parse_document, parse_document_with_broken_link_callback, ExtensionOptions,
-    ExtensionOptionsBuilder, ListStyleType, Options, ParseOptions, ParseOptionsBuilder, Plugins,
-    PluginsBuilder, RenderOptions, RenderOptionsBuilder, RenderPlugins, RenderPluginsBuilder,
+    parse_document, parse_document_with_broken_link_callback, BrokenLinkReference,
+    ExtensionOptions, ExtensionOptionsBuilder, ListStyleType, Options, ParseOptions,
+    ParseOptionsBuilder, Plugins, PluginsBuilder, RenderOptions, RenderOptionsBuilder,
+    RenderPlugins, RenderPluginsBuilder,
 };
 pub use typed_arena::Arena;
 pub use xml::format_document as format_xml;

src/parser/inlines.rs

@@ -8,7 +8,10 @@ use crate::nodes::{
 use crate::parser::autolink;
 #[cfg(feature = "shortcodes")]
 use crate::parser::shortcodes::NodeShortCode;
-use crate::parser::{unwrap_into_2, unwrap_into_copy, AutolinkType, Callback, Options, Reference};
+use crate::parser::{
+    unwrap_into_2, unwrap_into_copy, AutolinkType, BrokenLinkReference, Callback, Options,
+    Reference,
+};
 use crate::scanners;
 use crate::strings::{self, is_blank, Case};
 use std::cell::{Cell, RefCell};
@@ -1530,6 +1533,7 @@ impl<'a, 'r, 'o, 'd, 'i, 'c, 'subj> Subject<'a, 'r, 'o, 'd, 'i, 'c, 'subj> {
         }
 
         // Need to normalize both to lookup in refmap and to call callback
+        let unfolded_lab = lab.to_owned();
         let lab = strings::normalize_label(&lab, Case::Fold);
         let mut reff = if found_label {
             self.refmap.lookup(&lab)
@@ -1540,7 +1544,11 @@ impl<'a, 'r, 'o, 'd, 'i, 'c, 'subj> Subject<'a, 'r, 'o, 'd, 'i, 'c, 'subj> {
         // Attempt to use the provided broken link callback if a reference cannot be resolved
         if reff.is_none() {
             if let Some(ref mut callback) = self.callback {
-                reff = callback(&lab).map(|(url, title)| Reference { url, title });
+                reff = callback(BrokenLinkReference {
+                    normalized: &lab,
+                    original: &unfolded_lab,
+                })
+                .map(|(url, title)| Reference { url, title });
             }
         }
 

src/parser/mod.rs

@@ -72,7 +72,7 @@ pub fn parse_document<'a>(
 /// described in the [GFM spec](https://github.github.com/gfm/#matches).
 ///
 /// ```
-/// use comrak::{Arena, parse_document_with_broken_link_callback, format_html, Options};
+/// use comrak::{Arena, parse_document_with_broken_link_callback, format_html, Options, BrokenLinkReference};
 /// use comrak::nodes::{AstNode, NodeValue};
 ///
 /// # fn main() -> std::io::Result<()> {
@@ -83,7 +83,7 @@ pub fn parse_document<'a>(
 ///     &arena,
 ///     "# Cool input!\nWow look at this cool [link][foo]. A [broken link] renders as text.",
 ///     &Options::default(),
-///     Some(&mut |link_ref: &str| match link_ref {
+///     Some(&mut |link_ref: BrokenLinkReference| match link_ref.normalized {
 ///         "foo" => Some((
 ///             "https://www.rust-lang.org/".to_string(),
 ///             "The Rust Language".to_string(),
@@ -122,7 +122,20 @@ pub fn parse_document_with_broken_link_callback<'a, 'c>(
     parser.finish(linebuf)
 }
 
-type Callback<'c> = &'c mut dyn FnMut(&str) -> Option<(String, String)>;
+type Callback<'c> = &'c mut dyn FnMut(BrokenLinkReference) -> Option<(String, String)>;
+
+/// Struct to the broken link callback, containing details on the link reference
+/// which failed to find a match.
+#[derive(Debug)]
+pub struct BrokenLinkReference<'l> {
+    /// The normalized reference link label. Unicode case folding is applied;
+    /// see <https://github.com/commonmark/commonmark-spec/issues/695> for a
+    /// discussion on the details of what this exactly means.
+    pub normalized: &'l str,
+
+    /// The original text in the link label.
+    pub original: &'l str,
+}
 
 pub struct Parser<'a, 'o, 'c> {
     arena: &'a Arena<AstNode<'a>>,

src/tests/api.rs

@@ -1,3 +1,5 @@
+use parser::BrokenLinkReference;
+
 use crate::{
     adapters::{HeadingAdapter, HeadingMeta, SyntaxHighlighterAdapter},
     nodes::Sourcepos,
@@ -31,7 +33,9 @@ fn exercise_full_api() {
         &arena,
         "document",
         &default_options,
-        Some(&mut |_: &str| Some(("abc".to_string(), "xyz".to_string()))),
+        Some(&mut |blr: BrokenLinkReference| {
+            Some((blr.normalized.to_owned(), blr.original.to_owned()))
+        }),
     );
 
     let mut extension = ExtensionOptionsBuilder::default();