mdq 0.10.0

Select and render specific elements in a Markdown document
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::md_elem::elem::*;
use std::borrow::Borrow;

#[derive(Default, Copy, Clone)]
pub(crate) struct InlineToStringOpts {
    pub(crate) footnotes: FootnoteToString,
}

#[derive(Default, Copy, Clone)]
pub(crate) enum FootnoteToString {
    /// Includes all the surrounding Markdown. If the footnote id is `"1"`, this will render as `[^1]`.
    #[default]
    IncludeMarkdown,

    /// Includes only the footnote id. If the footnote id is `"1"`, this will render as `1`.
    OnlyFootnoteId,
}

pub(crate) fn inlines_to_plain_string<N: Borrow<Inline>>(inlines: &[N], opts: InlineToStringOpts) -> String {
    let mut result = String::with_capacity(inlines.len() * 5); // random guess
    build_inlines(&mut result, inlines, opts);
    result
}

fn build_inlines<N: Borrow<Inline>>(out: &mut String, inlines: &[N], opts: InlineToStringOpts) {
    for inline in inlines {
        build_inline(out, inline.borrow(), opts);
    }
}

fn build_inline(out: &mut String, elem: &Inline, opts: InlineToStringOpts) {
    match elem {
        Inline::Span(Span { children, .. }) => build_inlines(out, children, opts),
        Inline::Text(Text { value, .. }) => out.push_str(value),
        Inline::Link(Link::Standard(standard_link)) => build_inlines(out, &standard_link.display, opts),
        Inline::Link(Link::Autolink(autolink)) => out.push_str(&autolink.url),
        Inline::Image(Image { alt, .. }) => out.push_str(alt),
        Inline::Footnote(footnote) => {
            if matches!(opts.footnotes, FootnoteToString::IncludeMarkdown) {
                out.push_str("[^");
            }
            out.push_str(footnote.as_str());
            if matches!(opts.footnotes, FootnoteToString::IncludeMarkdown) {
                out.push(']');
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::md_elem::*;
    use indoc::indoc;

    use crate::util::utils_for_test::*;

    variants_checker!(VARIANTS_CHECKER = Inline {
        Span(Span{ variant: SpanVariant::Delete, .. }),
        Span(Span{ variant: SpanVariant::Emphasis, .. }),
        Span(Span{ variant: SpanVariant::Strong, .. }),
        Text(Text { variant: TextVariant::Plain, .. }),
        Text(Text { variant: TextVariant::Code, .. }),
        Text(Text { variant: TextVariant::Math, .. }),
        Text(Text { variant: TextVariant::InlineHtml, .. }),
        Link { .. },
        Image { .. },
        Footnote(_),
    });

    #[test]
    fn spans() {
        check("_hello world_", "hello world");
        check("**hello world**", "hello world");
        check("~~hello world~~", "hello world");
    }

    #[test]
    fn texts() {
        check("hello world", "hello world");
        check("`hello world`", "hello world");
        check("$hello world$", "hello world");
        // html is covered separately, since it isn't wrapped in a paragraph: see issue #34
    }

    #[test]
    fn inline_html() {
        let md_elems = MdDoc::parse("Hello <foo> world", &ParseOptions::gfm()).unwrap().roots;
        unwrap!(&md_elems[0], MdElem::Paragraph(contents));
        unwrap!(&contents.body[1], inline @ Inline::Text(_));
        VARIANTS_CHECKER.see(inline);
        let actual = inlines_to_plain_string(&contents.body, Default::default());
        assert_eq!(&actual, "Hello <foo> world");
    }

    #[test]
    fn links() {
        check("[foo](https://example.com)", "foo");
        check("[foo _with emphasis_](https://example.com)", "foo with emphasis");
        check(
            indoc! {r#"
            [foo][1]

            [1]: https://example.com"#},
            "foo",
        )
    }

    #[test]
    fn images() {
        check("![foo](https://example.com)", "foo");
        check("![foo _with emphasis_](https://example.com)", "foo with emphasis"); // md is ignored in alt
        check(
            indoc! {r#"
            ![foo][1]

            [1]: https://example.com"#},
            "foo",
        )
    }

    #[test]
    fn footnote() {
        check(
            indoc! {r#"
            [^1]

            [^1]: my footnote"#},
            "[^1]",
        )
    }

    /// Because this is such simple functionality, we're just going to do a simple end-to-end test from original
    /// markdown to plain text.
    fn check(md: &str, expect: &str) {
        let mut options = ParseOptions::gfm();
        options.mdast_options.constructs.math_text = true;
        let md_elems = MdDoc::parse(md, &options).unwrap().roots;
        unwrap!(&md_elems[0], MdElem::Paragraph(p));
        p.body.iter().for_each(|inline| VARIANTS_CHECKER.see(inline));
        let actual = inlines_to_plain_string(&p.body, Default::default());
        assert_eq!(&actual, expect);
    }
}