Struct ReferenceMap

pub struct ReferenceMap(/* private fields */);

Storage for parsed references

If you have some external source for your link references, you can add them like this:

use markdown_that::parser::block::builtin::BlockParserRule;
use markdown_that::parser::core::{CoreRule, Root};
use markdown_that::plugins::cmark::block::reference::{ReferenceMap, DefaultReferenceMap, CustomReferenceMap};
use markdown_that::{MarkdownThat, Node};

let md = &mut MarkdownThat::new();
markdown_that::plugins::cmark::add(md);

#[derive(Debug, Default)]
struct RefMapOverride(DefaultReferenceMap);
impl CustomReferenceMap for RefMapOverride {
    fn insert(&mut self, label: String, destination: String, title: Option<String>) -> bool {
        self.0.insert(label, destination, title)
    }

    fn get(&self, label: &str) -> Option<(&str, Option<&str>)> {
        // override a specific link
        if label == "rust" {
            return Some((
                "https://www.rust-lang.org/",
                Some("The Rust Language"),
            ));
        }
        self.0.get(label)
    }
}

struct AddCustomReferences;
impl CoreRule for AddCustomReferences {
    fn run(root: &mut Node, _: &MarkdownThat) {
        let data = root.cast_mut::<Root>().unwrap();
        data.ext.insert(ReferenceMap::new(RefMapOverride::default()));
    }
}

md.add_rule::<AddCustomReferences>()
    .before::<BlockParserRule>();

let html = md.parse("[rust]").render();
assert_eq!(
    html.trim(),
    r#"<p><a href="https://www.rust-lang.org/" title="The Rust Language">rust</a></p>"#
);

You can also view all references that the user created by adding the following rule:

use markdown_that::parser::core::{CoreRule, Root};
use markdown_that::plugins::cmark::block::reference::{ReferenceMap, DefaultReferenceMap};
use markdown_that::{MarkdownThat, Node};

let md = &mut MarkdownThat::new();
markdown_that::plugins::cmark::add(md);

let ast = md.parse("[hello]: world");
let root = ast.node_value.downcast_ref::<Root>().unwrap();
let refmap = root.ext.get::<ReferenceMap>()
    .map(|m| m.downcast_ref::<DefaultReferenceMap>().expect("expect references to be handled by default map"));

let mut labels = vec![];
if let Some(refmap) = refmap {
    for (label, _dest, _title) in refmap.iter() {
        labels.push(label);
    }
}

assert_eq!(labels, ["hello"]);

Implementations

impl ReferenceMap

pub fn new(custom_map: impl CustomReferenceMap + 'static) -> Self

Trait Implementations

impl Debug for ReferenceMap

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ReferenceMap

fn default() -> Self

Returns the “default value” for a type.

impl Deref for ReferenceMap

type Target = Box<dyn CustomReferenceMap>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for ReferenceMap

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl RootExt for ReferenceMap