Struct markdown_it::Node

pub struct Node {
    pub children: Vec<Node>,
    pub srcmap: Option<SourcePos>,
    pub ext: NodeExtSet,
    pub attrs: Vec<(&'static str, String)>,
    pub node_type: TypeKey,
    pub node_value: Box<dyn NodeValue>,
}

Single node in the CommonMark AST.

Fields

children: Vec<Node>

Array of child nodes.

srcmap: Option<SourcePos>

Source mapping info.

ext: NodeExtSet

Custom data specific to this token.

attrs: Vec<(&'static str, String)>

Additional attributes to be added to resulting html.

node_type: TypeKey

Type name, used for debugging.

node_value: Box<dyn NodeValue>

Storage for arbitrary token-specific data.

Implementations

impl Node

pub fn new<T: NodeValue>(value: T) -> Self

Create a new Node with a custom value.

Examples found in repository

examples/ferris/inline_rule.rs (line 52)

    fn run(state: &mut InlineState) -> Option<(Node, usize)> {
        let input = &state.src[state.pos..state.pos_max]; // look for stuff at state.pos
        if !input.starts_with(CRAB_CLAW) { return None; } // return None if it's not found

        // return new node and length of this structure
        Some((
            Node::new(InlineFerris),
            CRAB_CLAW.len(),
        ))
    }

examples/ferris/core_rule.rs (line 57)

    fn run(root: &mut Node, _: &MarkdownIt) {
        let mut counter = 0;

        // walk through AST recursively and count the number of two
        // custom nodes added by other two rules
        root.walk(|node, _| {
            if node.is::<InlineFerris>() || node.is::<BlockFerris>() {
                counter += 1;
            }
        });

        // append a counter to the root as a custom node
        root.children.push(Node::new(FerrisCounter(counter)))
    }

examples/ferris/block_rule.rs (line 63)

    fn run(state: &mut BlockState) -> Option<(Node, usize)> {
        // get contents of a line number `state.line` and check it
        let line = state.get_line(state.line).trim();
        if !line.starts_with(CRAB_CLAW) { return None; }
        if !line.ends_with(CRAB_CLAW)   { return None; }

        // require any number of `-` in between, but no less than 4
        if line.len() < CRAB_CLAW.len() * 2 + 4 { return None; }

        // and make sure no other characters are present there
        let dashes = &line[CRAB_CLAW.len()..line.len()-CRAB_CLAW.len()];
        if dashes.chars().any(|c| c != '-') { return None; }

        // return new node and number of lines it occupies
        Some((
            Node::new(BlockFerris),
            1,
        ))
    }

pub fn name(&self) -> &'static str

Return std::any::type_name() of node value.

pub fn is<T: NodeValue>(&self) -> bool

Check that this node value is of given type.

Examples found in repository

examples/ferris/core_rule.rs (line 51)

    fn run(root: &mut Node, _: &MarkdownIt) {
        let mut counter = 0;

        // walk through AST recursively and count the number of two
        // custom nodes added by other two rules
        root.walk(|node, _| {
            if node.is::<InlineFerris>() || node.is::<BlockFerris>() {
                counter += 1;
            }
        });

        // append a counter to the root as a custom node
        root.children.push(Node::new(FerrisCounter(counter)))
    }

pub fn cast<T: NodeValue>(&self) -> Option<&T>

Downcast node value to specific type.

pub fn cast_mut<T: NodeValue>(&mut self) -> Option<&mut T>

Downcast node value to specific type.

pub fn render(&self) -> String

Render this node to HTML.

Examples found in repository

examples/ferris/main.rs (line 22)

fn main() {
    // create markdown parser
    let md = &mut markdown_it::MarkdownIt::new();

    // add commonmark syntax, you almost always want to do that
    markdown_it::plugins::cmark::add(md);

    // add custom three rules described above
    inline_rule::add(md);
    block_rule::add(md);
    core_rule::add(md);

    // and now you can use it
    let html = md.parse(r#"
(\/) hello world (\/)
(\/)-------------(\/)
    "#).render();

    print!("{html}");

    assert_eq!(html.trim(), r#"
<p><span class="ferris-inline">🦀</span> hello world <span class="ferris-inline">🦀</span></p>
<div class="ferris-block"><img src="https://upload.wikimedia.org/wikipedia/commons/0/0f/Original_Ferris.svg"></div>
<footer class="ferris-counter">There are 3 crabs lurking in this document.</footer>
    "#.trim());
}

pub fn xrender(&self) -> String

Render this node to XHTML, it adds slash to self-closing tags like this: <img />.

This mode exists for compatibility with CommonMark tests.

pub fn replace<T: NodeValue>(&mut self, value: T)

Replace custom value with another value (this is roughly equivalent to replacing the entire node and copying children and sourcemaps).

pub fn walk<'a>(&'a self, f: impl FnMut(&'a Node, u32))

Execute function f recursively on every member of AST tree (using preorder deep-first search).

Examples found in repository

examples/ferris/core_rule.rs (lines 50-54)

    fn run(root: &mut Node, _: &MarkdownIt) {
        let mut counter = 0;

        // walk through AST recursively and count the number of two
        // custom nodes added by other two rules
        root.walk(|node, _| {
            if node.is::<InlineFerris>() || node.is::<BlockFerris>() {
                counter += 1;
            }
        });

        // append a counter to the root as a custom node
        root.children.push(Node::new(FerrisCounter(counter)))
    }

pub fn walk_mut(&mut self, f: impl FnMut(&mut Node, u32))

Execute function f recursively on every member of AST tree (using preorder deep-first search).

pub fn walk_post(&self, f: impl FnMut(&Node, u32))

Execute function f recursively on every member of AST tree (using postorder deep-first search).

pub fn walk_post_mut(&mut self, f: impl FnMut(&mut Node, u32))

Execute function f recursively on every member of AST tree (using postorder deep-first search).

pub fn collect_text(&self) -> String

Walk recursively through child nodes and collect all text nodes into a single string.

Trait Implementations

impl Debug for Node

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

Formats the value using the given formatter.

impl Default for Node

fn default() -> Self

Create empty Node. Empty node should only be used as placeholder for functions like std::mem::take, and it cannot be rendered.

impl Drop for Node

fn drop(&mut self)

Executes the destructor for this type.