comrak 0.58.0

A 100% CommonMark-compatible GitHub Flavored Markdown parser and formatter
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

use pretty_assertions::assert_eq;
use std::cell::Cell;

use super::*;

fn parse_stopping_on_call<'a>(
    arena: &'a Arena<'a>,
    input: &str,
    options: &Options,
    stop_at: usize,
) -> (Result<Node<'a>, ParseCancelled>, usize) {
    let calls = Cell::new(0);
    let result = try_parse_document(arena, input, options, &|| {
        calls.set(calls.get() + 1);
        calls.get() >= stop_at
    });
    (result, calls.get())
}

fn mixed_input() -> String {
    [
        include_str!("fixtures/alerts.md"),
        include_str!("fixtures/description_lists.md"),
        include_str!("fixtures/math_code.md"),
        include_str!("fixtures/math_dollars.md"),
        include_str!("fixtures/multiline_alerts.md"),
        include_str!("fixtures/multiline_blockquote.md"),
        include_str!("fixtures/wikilinks_title_after_pipe.md"),
        include_str!("fixtures/wikilinks_title_before_pipe.md"),
        "| a | b |\n|---|---|\n| [ ] c | d@e.com |\n\n",
        "- [x] www.example.com[^1] ^[inline *note*]\n  - é **ü** \"smart\" --- ok\n\n",
        "[^1]: The *footnote*.\n\n[ref]: /url 'title'\n\n[ref] and [missing]\n",
    ]
    .concat()
}

fn many_options() -> Options<'static> {
    let mut options = Options::default();
    options.extension.strikethrough = true;
    options.extension.table = true;
    options.extension.autolink = true;
    options.extension.tasklist = true;
    options.extension.superscript = true;
    options.extension.header_id_prefix = Some(String::new());
    options.extension.footnotes = true;
    options.extension.inline_footnotes = true;
    options.extension.description_lists = true;
    options.extension.multiline_block_quotes = true;
    options.extension.alerts = true;
    options.extension.math_dollars = true;
    options.extension.math_code = true;
    options.extension.wikilinks_title_after_pipe = true;
    options.extension.underline = true;
    options.extension.spoiler = true;
    options.parse.smart = true;
    options.parse.relaxed_autolinks = true;
    options
}

#[test]
fn stops_block_parsing() {
    let input = "a\n\n".repeat(10_000);
    let arena = Arena::new();
    let (result, calls) = parse_stopping_on_call(&arena, &input, &Options::default(), 2);
    assert_eq!(result.unwrap_err(), ParseCancelled);
    assert_eq!(calls, 2);
    assert!(arena.len() < 200, "made {} nodes", arena.len());
}

#[test]
fn stops_inline_parsing() {
    let input = "a *b* ".repeat(20_000);
    let arena = Arena::new();
    let (result, calls) = parse_stopping_on_call(&arena, &input, &Options::default(), 2);
    assert_eq!(result.unwrap_err(), ParseCancelled);
    assert_eq!(calls, 2);
    assert!(arena.len() < 1_000, "made {} nodes", arena.len());
}

#[test]
fn stops_on_every_call() {
    let input = mixed_input();

    for sourcepos_chars in [false, true] {
        let mut options = many_options();
        options.parse.sourcepos_chars = sourcepos_chars;

        let arena = Arena::new();
        let (result, total) = parse_stopping_on_call(&arena, &input, &options, usize::MAX);
        result.unwrap();

        for stop_at in 1..=total {
            let arena = Arena::new();
            let (result, calls) = parse_stopping_on_call(&arena, &input, &options, stop_at);
            assert_eq!(
                result.unwrap_err(),
                ParseCancelled,
                "stopping on call {stop_at} of {total}"
            );
            assert_eq!(calls, stop_at);
        }

        let arena = Arena::new();
        let (result, calls) = parse_stopping_on_call(&arena, &input, &options, total + 1);
        result.unwrap();
        assert_eq!(calls, total);
    }
}

#[test]
fn output_unchanged_when_never_stopped() {
    let input = mixed_input();
    let mut options = many_options();
    options.render.sourcepos = true;

    let arena = Arena::new();
    let expected = parse_document(&arena, &input, &options);
    let actual = try_parse_document(&arena, &input, &options, &|| false).unwrap();

    let mut expected_xml = String::new();
    let mut actual_xml = String::new();
    format_xml(expected, &options, &mut expected_xml).unwrap();
    format_xml(actual, &options, &mut actual_xml).unwrap();
    assert_eq!(actual_xml, expected_xml);
}