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
134
135

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

#[test]
fn test_md033_kramdown_extensions() {
    let rule = MD033NoInlineHtml::default();

    // Kramdown extensions should not be flagged as HTML
    let content = r#"{::comment}
This is a comment that won't be rendered
{:/comment}

{::nomarkdown}
<div>This HTML is intentionally allowed</div>
{:/nomarkdown}

{::options parse_block_html="true" /}"#;

    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Kramdown, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty(), "Should not flag Kramdown extensions as HTML");
}

#[test]
fn test_md033_kramdown_block_attributes() {
    let rule = MD033NoInlineHtml::default();

    // Block attributes should not be flagged
    let content = r#"```ruby
puts "Hello"
```
{:.language-ruby .numberLines}

| Table | Header |
|-------|--------|
| Cell  | Cell   |
{:.table-striped}

> Blockquote
{:#special-quote}"#;

    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Kramdown, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty(), "Should not flag block attributes as HTML");
}

#[test]
fn test_md033_mixed_html_and_kramdown() {
    let rule = MD033NoInlineHtml::default();

    let content = r#"{::comment}
This is fine
{:/comment}

<div>This is HTML and should be flagged</div>

{:.class}

<span>Another HTML tag</span>

{::options key="value" /}"#;

    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Kramdown, None);
    let result = rule.check(&ctx).unwrap();
    // MD033 reports only opening tags
    assert_eq!(result.len(), 2, "Should only flag actual HTML tags (opening tags only)");
    assert!(result[0].message.contains("<div>"));
    assert!(result[1].message.contains("<span>"));
}

#[test]
fn test_md033_nested_kramdown_extensions() {
    let rule = MD033NoInlineHtml::default();

    let content = r#"{::comment}
Outer comment
{::comment}
Nested comment
{:/comment}
Back to outer
{:/comment}"#;

    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Kramdown, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty(), "Should handle nested Kramdown extensions");
}

#[test]
fn test_md033_invalid_kramdown_patterns() {
    let rule = MD033NoInlineHtml::default();

    // These look similar but are not valid Kramdown
    // and should not prevent HTML detection
    let content = r#"{:comment}  <!-- Missing second colon -->
{/comment}

<div>Regular HTML</div>

{just text in braces}

<span>More HTML</span>"#;

    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    // Should detect the actual HTML tags (opening tags only)
    assert_eq!(
        result.len(),
        2,
        "Should detect HTML tags despite invalid Kramdown patterns (opening tags only)"
    );
    assert!(result[0].message.contains("<div>"));
    assert!(result[1].message.contains("<span>"));
}

#[test]
fn test_md033_kramdown_with_allowed_html() {
    let rule = MD033NoInlineHtml::with_allowed(vec!["br".to_string(), "img".to_string()]);

    let content = r#"{::comment}
Comment here
{:/comment}

<br/>  <!-- Allowed -->
<img src="test.jpg"/>  <!-- Allowed -->
<div>Not allowed</div>

{:.class}"#;

    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Kramdown, None);
    let result = rule.check(&ctx).unwrap();
    // Should flag opening div tag only
    assert_eq!(result.len(), 1, "Should only flag non-allowed HTML (opening tag only)");
    assert!(result[0].message.contains("<div>"));
}