Struct 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());
}

examples/syntect/main.rs (line 88)

fn main() {
    #[cfg(not(feature = "syntect"))]
    {
        eprintln!("Run this example with the `syntect` feature enabled.");
        eprintln!("such as: cargo run --example syntect --features syntect");
        return;
    }

    let mut md_inline = markdown_it::MarkdownIt::new();
    markdown_it::plugins::cmark::add(&mut md_inline);
    markdown_it::plugins::extra::syntect::add(&mut md_inline);

    let mut md_classed = markdown_it::MarkdownIt::new();
    markdown_it::plugins::cmark::add(&mut md_classed);
    markdown_it::plugins::extra::syntect::add(&mut md_classed);
    markdown_it::plugins::extra::syntect::set_to_classed(&mut md_classed);

    let input_inline = r#"
parse with inline mode:

```rust {2}
fn main() {
    println!("Ciallo world!");
}
```
"#;
    let input_classed = r#"
parse with classed mode:

```rust {2}
fn main() {
    println!("Ciallo world!");
}
```
"#;

    let highlighted_line_css = r#"
.syntect-line-highlighted {
    background-color: #fffbdd;
    border-left: 4px solid #f9c513;
    padding-left: 12px;
}
"#;

    let html = format!(
        r#"<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Code highlight example</title>
  <style>
  body {{
    font-family: sans-serif;
    max-width: 800px;
    margin: 40px auto;
    padding: 20px;
  }}
  h2 {{
    margin-top: 40px;
  }}
  pre {{
    background-color: #f6f8fa;
    padding: 16px 0;
    border-radius: 6px;
    font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace;
    font-size: 14px;
    line-height: 1.5;
    overflow: auto;
  }}
  .syntect-line {{
    display: block;
    padding: 0 16px;
  }}
  {}
  {}
  </style>
</head>
<body>
  <h2>Inline Mode</h2>
  {}
  <h2>Classed Mode</h2>
  {}
</body>
</html>
"#,
        markdown_it::plugins::extra::syntect::theme_css(&md_classed).unwrap_or_default(),
        highlighted_line_css,
        md_inline.parse(input_inline).render(),
        md_classed.parse(input_classed).render(),
    );

    let path = "examples/syntect/demo.html";
    std::fs::write(path, html).expect("write file failed");
    println!("success write to '{}'", path);
}

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.