core-markdown 0.2.0

CommonMark compliant markdown parser in Rust with ASTs and extensions
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

// Released under the MIT License.
// Copyright, 2026, by Samuel Williams.

use super::Options;

#[test]
fn validates_markdown_serialization_markers() {
    let options = Options::default();
    assert_eq!(options.check_bullet().unwrap(), '-');
    assert_eq!(options.check_bullet_ordered().unwrap(), '.');
    assert_eq!(options.check_bullet_other().unwrap(), '*');
    assert_eq!(options.check_emphasis().unwrap(), '*');
    assert_eq!(options.check_fence().unwrap(), '`');
    assert_eq!(options.check_quote().unwrap(), '"');
    assert_eq!(options.check_rule().unwrap(), '*');
    assert_eq!(options.check_rule_repetition().unwrap(), 3);
    assert_eq!(options.check_strong().unwrap(), '*');

    for bullet in ['+', '-'] {
        let options = Options {
            bullet,
            ..Options::default()
        };
        assert_eq!(options.check_bullet().unwrap(), bullet);
    }

    for bullet in ['.', ')'] {
        let options = Options {
            bullet_ordered: bullet,
            ..Options::default()
        };
        assert_eq!(options.check_bullet_ordered().unwrap(), bullet);
    }

    let options = Options {
        bullet: '+',
        bullet_other: '-',
        ..Options::default()
    };
    assert_eq!(options.check_bullet_other().unwrap(), '*');

    for marker in ['_', '*'] {
        let options = Options {
            emphasis: marker,
            strong: marker,
            ..Options::default()
        };
        assert_eq!(options.check_emphasis().unwrap(), marker);
        assert_eq!(options.check_strong().unwrap(), marker);
    }

    let options = Options {
        fence: '~',
        quote: '\'',
        rule: '-',
        rule_repetition: 4,
        ..Options::default()
    };
    assert_eq!(options.check_fence().unwrap(), '~');
    assert_eq!(options.check_quote().unwrap(), '\'');
    assert_eq!(options.check_rule().unwrap(), '-');
    assert_eq!(options.check_rule_repetition().unwrap(), 4);

    let invalid = Options {
        bullet: 'x',
        ..Options::default()
    };
    assert!(invalid.check_bullet().is_err());

    let invalid = Options {
        bullet_ordered: 'x',
        ..Options::default()
    };
    assert!(invalid.check_bullet_ordered().is_err());

    let invalid = Options {
        bullet: '*',
        bullet_other: 'x',
        ..Options::default()
    };
    assert!(invalid.check_bullet_other().is_err());

    let invalid = Options {
        bullet: 'x',
        bullet_other: '-',
        ..Options::default()
    };
    assert!(invalid.check_bullet_other().is_err());

    let invalid = Options {
        bullet: '*',
        bullet_other: '*',
        ..Options::default()
    };
    assert!(invalid.check_bullet_other().is_err());

    for options in [
        Options {
            emphasis: 'x',
            ..Options::default()
        },
        Options {
            strong: 'x',
            ..Options::default()
        },
        Options {
            fence: 'x',
            ..Options::default()
        },
        Options {
            quote: 'x',
            ..Options::default()
        },
        Options {
            rule: 'x',
            ..Options::default()
        },
        Options {
            rule_repetition: 2,
            ..Options::default()
        },
    ] {
        assert!(options.check_emphasis().is_err() || options.emphasis == '*');
        assert!(options.check_strong().is_err() || options.strong == '*');
        assert!(options.check_fence().is_err() || options.fence == '`');
        assert!(options.check_quote().is_err() || options.quote == '"');
        assert!(options.check_rule().is_err() || options.rule == '*');
        assert!(options.check_rule_repetition().is_err() || options.rule_repetition == 3);
    }
}