rumdl 0.1.88

A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use rumdl_lib::lint_context::LintContext;
use rumdl_lib::rule::Rule;
use rumdl_lib::rules::MD001HeadingIncrement;

#[test]
pub fn test_md001_valid() {
    let rule = MD001HeadingIncrement::default();
    let content = "# Heading 1\n## Heading 2\n### Heading 3\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty());
}

#[test]
pub fn test_md001_invalid() {
    let rule = MD001HeadingIncrement::default();
    let content = "# Heading 1\n### Heading 3\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1);
    assert_eq!(result[0].line, 2);
    assert_eq!(result[0].message, "Expected heading level 2, but found heading level 3");
}

#[test]
pub fn test_md001_multiple_violations() {
    let rule = MD001HeadingIncrement::default();
    // H1 → H3 → H4: check() tracks the fixed level for idempotent fixes.
    // H3 is flagged (expected H2), H4 is flagged (expected H3 after fixed H2).
    let content = "# Heading 1\n### Heading 3\n#### Heading 4\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 2);
    assert_eq!(result[0].line, 2);
    assert_eq!(result[1].line, 3);
}

#[test]
pub fn test_md001_fix() {
    let rule = MD001HeadingIncrement::default();
    let content = "# Heading 1\n### Heading 3\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "# Heading 1\n## Heading 3\n");
}

#[test]
pub fn test_md001_no_headings() {
    let rule = MD001HeadingIncrement::default();
    let content = "This is a paragraph\nwith no headings.\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty());
}

#[test]
pub fn test_md001_single_heading() {
    let rule = MD001HeadingIncrement::default();
    let content = "# Single Heading\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty());
}

#[test]
pub fn test_md001_atx_and_setext() {
    let rule = MD001HeadingIncrement::default();
    let content = "# Heading 1\nHeading 2\n---------\n### Heading 3\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty());
}

#[test]
pub fn test_md001_ignores_headings_in_html_comments() {
    let rule = MD001HeadingIncrement::default();
    let content = "# Real Heading 1\n\n<!--\n## This heading is in a comment\n### This one too\n-->\n\n### This should trigger MD001\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();

    // Should get exactly one warning for the level 3 heading that comes after level 1
    assert_eq!(result.len(), 1, "Should have one MD001 violation, but got: {result:?}");
    assert_eq!(result[0].line, 8, "MD001 violation should be on line 8");
    assert_eq!(result[0].message, "Expected heading level 2, but found heading level 3");
}

#[test]
pub fn test_md001_html_comments_dont_affect_heading_sequence() {
    let rule = MD001HeadingIncrement::default();
    let content = "# Heading 1\n\n<!--\n#### Random comment heading\n-->\n\n## Heading 2\n### Heading 3\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();

    // Should have no violations - the comment heading shouldn't affect the sequence
    assert!(
        result.is_empty(),
        "Should have no violations when HTML comment headings don't interfere, but got: {result:?}"
    );
}

/// Setext H1 followed by a deep ATX heading: the ATX heading is fixed to H2.
#[test]
pub fn test_md001_setext_h1_followed_by_deep_atx() {
    let rule = MD001HeadingIncrement::default();
    let content = "Title\n=====\n\n#### Fourth Level\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);

    let warnings = rule.check(&ctx).unwrap();
    assert_eq!(warnings.len(), 1, "H4 after Setext H1 should be flagged");
    assert!(warnings[0].message.contains("Expected heading level 2"));

    let fixed = rule.fix(&ctx).unwrap();
    assert!(
        fixed.contains("## Fourth Level"),
        "H4 should become H2 (ATX), got: {fixed}"
    );

    // Verify fix is idempotent
    let ctx2 = LintContext::new(&fixed, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let fixed2 = rule.fix(&ctx2).unwrap();
    assert_eq!(fixed, fixed2, "fix() must be idempotent");
}

/// Parametric test: for every warning, check()'s fix replacement matches fix()'s output line.
#[test]
pub fn test_md001_check_fix_consistency() {
    let rule = MD001HeadingIncrement::default();

    let inputs = [
        "# H1\n### H3\n",
        "# H1\n#### H4\n##### H5\n",
        "## H2\n##### H5\n",
        "# A\n### B\n# C\n#### D\n",
        "Title\n=====\n\n#### Deep\n",
        "---\ntitle: T\n---\n\n#### Deep\n",
        "# H1\n  ### Indented H3\n",
    ];

    for input in &inputs {
        let ctx = LintContext::new(input, rumdl_lib::config::MarkdownFlavor::Standard, None);
        let warnings = rule.check(&ctx).unwrap();
        let fixed = rule.fix(&ctx).unwrap();
        let fixed_lines: Vec<&str> = fixed.lines().collect();

        for w in &warnings {
            if let Some(ref fix) = w.fix {
                let idx = w.line - 1;
                assert!(
                    idx < fixed_lines.len(),
                    "Line {} out of range for input: {input:?}",
                    w.line
                );
                assert_eq!(
                    fix.replacement, fixed_lines[idx],
                    "check()/fix() diverge at line {} for input: {input:?}",
                    w.line
                );
            }
        }
    }
}