rushdown 0.18.0

A 100% CommonMark-compatible GitHub Flavored Markdown parser and renderer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use crate::{
    as_type_data_mut,
    ast::{Arena, NodeRef, Paragraph},
    parser::{BlockParser, Context, State},
    text,
    text::Reader as _,
};

/// [`BlockParser`] for paragraphs.
#[derive(Debug, Default)]
pub struct ParagraphParser {}

impl ParagraphParser {
    /// Returns a new [`ParagraphParser`].
    pub fn new() -> Self {
        Self::default()
    }
}

impl BlockParser for ParagraphParser {
    fn trigger(&self) -> &[u8] {
        &[]
    }

    fn open(
        &self,
        arena: &mut Arena,
        _parent_ref: NodeRef,
        reader: &mut text::BasicReader,
        _ctx: &mut Context,
    ) -> Option<(NodeRef, State)> {
        let segment = reader.peek_line_segment()?;
        if segment.is_blank(reader.source()) {
            return None;
        }
        let node_ref = arena.new_node(Paragraph::new());
        as_type_data_mut!(arena, node_ref, Block).append_source_line(segment);

        reader.advance_to_eol();
        Some((node_ref, State::NO_CHILDREN))
    }

    fn cont(
        &self,
        arena: &mut Arena,
        node_ref: NodeRef,
        reader: &mut text::BasicReader,
        _ctx: &mut Context,
    ) -> Option<State> {
        let segment = reader.peek_line_segment()?;
        if segment.is_blank(reader.source()) {
            return None;
        }
        let block = as_type_data_mut!(arena, node_ref, Block);
        // We do not trim leading spaces here
        // ParagraphTransformer may need them
        block.append_source_line(segment);
        reader.advance_to_eol();
        Some(State::NO_CHILDREN)
    }

    fn close(
        &self,
        arena: &mut Arena,
        node_ref: NodeRef,
        reader: &mut text::BasicReader,
        _ctx: &mut Context,
    ) {
        let block = as_type_data_mut!(arena, node_ref, Block);
        // trim leading spaces
        for i in 0..block.source().len() {
            let line = block.source()[i];
            block.replace_source_line(i, line.trim_left_space(reader.source()));
        }
        // trim trailing spaces
        if let Some(last) = block.source().last() {
            block.replace_source_line(
                block.source().len() - 1,
                last.trim_right_space(reader.source()),
            );
        }
        // remove empty paragraph
        if block.source().is_empty() {
            node_ref.delete(arena);
        }
    }
}