rumdl 0.2.21

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

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

#[test]
fn test_md026_with_kramdown_header_ids() {
    let rule = MD026NoTrailingPunctuation::default();

    // Header with punctuation and custom ID - should still trigger
    let content = "# This is a heading. {#custom-id}";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1);
    assert!(result[0].message.contains("punctuation"));

    // Header with punctuation and no ID - should trigger
    let content = "# This is a heading.";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1);
    assert!(result[0].message.contains("punctuation"));

    // Multiple headers with IDs - should still flag punctuation
    let content = r#"# First Header. {#first}

## Second Header! {#second}

### Third Header: {#third}

#### Fourth Header; {#fourth}"#;
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 4, "Should flag all headers with trailing punctuation");

    // Headers with IDs but no punctuation - should not trigger
    let content = r#"# First Header {#first}

## Second Header {#second}"#;
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty(), "Should not flag headers without punctuation");
}

#[test]
fn test_md026_fix_preserves_kramdown_ids() {
    let rule = MD026NoTrailingPunctuation::default();

    // Test that fix removes punctuation but preserves the header ID
    let content = "# Header with period. {#my-id}";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "# Header with period {#my-id}");

    // Test fix on header without ID
    let content = "# Header with period.";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "# Header with period");
}

#[test]
fn test_md026_complex_kramdown_ids() {
    let rule = MD026NoTrailingPunctuation::default();

    // Complex ID patterns - all should trigger due to punctuation
    let content = r#"# Heading. {#id-with-dashes}

## Another. {#id-with-colons:test}

### Yet Another. {#id_with_underscores}

#### Final. {#id123}"#;
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 4, "Should flag all headers with punctuation");

    // Test with invalid ID format (dots not allowed) - invalid IDs are not stripped
    // So the heading text is "Another. {#id.with.dots}" which ends with '}' not punctuation
    let content = "## Another. {#id.with.dots}";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(
        result.len(),
        0,
        "Should not flag - invalid ID not stripped, doesn't end with punctuation"
    );
}

#[test]
fn test_md026_with_trailing_hashes_and_ids() {
    let rule = MD026NoTrailingPunctuation::default();

    // ATX closed heading with ID (no punctuation, correct format)
    let content = "# Heading # {#id}";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty(), "Should not flag when no punctuation");

    // ATX closed heading with punctuation and ID
    // Even though the heading has a custom ID, we still flag the trailing punctuation
    let content = "# Heading. # {#id}";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1, "Should flag punctuation even with custom ID");

    // ATX closed heading without ID (should trigger)
    let content = "# Heading. #";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1);
}

#[test]
fn test_md026_false_positives() {
    let rule = MD026NoTrailingPunctuation::default();

    // Not actually a header ID (missing #)
    // The heading text is "Heading. {custom-id}" which ends with '}' not punctuation
    let content = "# Heading. {custom-id}";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(
        result.len(),
        0,
        "Should not flag - ends with curly brace not punctuation"
    );

    // Header ID in middle of text
    let content = "# Heading {#id} with more text.";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1, "Should flag - ID is not at the end");
}