rumdl 0.1.76

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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

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

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

#[test]
fn test_md012_invalid() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "Line 1\n\n\nLine 2\n\n\n\nLine 3\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 3);
    assert_eq!(result[0].line, 3);
    assert_eq!(result[0].message, "Multiple consecutive blank lines between content");
    assert_eq!(result[1].line, 6);
    assert_eq!(result[1].message, "Multiple consecutive blank lines between content");
    assert_eq!(result[2].line, 7);
    assert_eq!(result[2].message, "Multiple consecutive blank lines between content");
}

#[test]
fn test_md012_start_end() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "\n\nLine 1\nLine 2\n\n\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[0].message, "Multiple consecutive blank lines at start of file");
    assert_eq!(result[1].line, 6);
    assert_eq!(result[1].message, "Multiple consecutive blank lines at end of file");
}

#[test]
fn test_md012_code_blocks() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "Line 1\n\n```\n\n\nCode\n\n\n```\nLine 2\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty()); // Multiple blank lines in code blocks are allowed
}

#[test]
fn test_md012_front_matter() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "---\ntitle: Test\n\n\ndescription: Test\n---\n\nContent\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty()); // Multiple blank lines in front matter are allowed
}

#[test]
fn test_md012_custom_maximum() {
    let rule = MD012NoMultipleBlanks::new(2);
    let content = "Line 1\n\n\nLine 2\n\n\n\nLine 3\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    // Only the second group (3 blanks > maximum 2) is invalid, reporting 1 excess line
    assert_eq!(result.len(), 1);
    assert_eq!(result[0].line, 7); // The third blank line in the second sequence
    assert_eq!(result[0].message, "Multiple consecutive blank lines between content");
}

#[test]
fn test_md012_fix() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "Line 1\n\n\nLine 2\n\n\n\nLine 3\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.fix(&ctx).unwrap();
    assert_eq!(result, "Line 1\n\nLine 2\n\nLine 3\n");
}

#[test]
fn test_md012_fix_with_code_blocks() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "Line 1\n\n\n```\n\n\nCode\n\n\n```\nLine 2\n\n\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.fix(&ctx).unwrap();
    // Trailing blanks at EOF are removed (matching markdownlint-cli)
    assert_eq!(result, "Line 1\n\n```\n\n\nCode\n\n\n```\nLine 2\n");
}

#[test]
fn test_md012_fix_with_front_matter() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "---\ntitle: Test\n\n\ndescription: Test\n---\n\n\n\nContent\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.fix(&ctx).unwrap();
    assert_eq!(result, "---\ntitle: Test\n\n\ndescription: Test\n---\n\nContent\n");
}

#[test]
fn test_md012_whitespace_lines() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "Line 1\n  \n \t \nLine 2\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    // Expects 1 warning for the excess whitespace line
    assert_eq!(result.len(), 1);
    assert_eq!(result[0].line, 3); // The second whitespace line is excess
    assert_eq!(result[0].message, "Multiple consecutive blank lines between content");
}

#[test]
fn test_md012_indented_code_blocks() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "Line 1\n\n    code block\n\n    more code\n\nLine 2\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty()); // Multiple blank lines in indented code blocks are allowed
}

#[test]
fn test_md012_indented_fenced_code_blocks() {
    let rule = MD012NoMultipleBlanks::default();
    let content = "Text\n\n    ```bash\n    code\n    ```\n\nMore text\n";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty()); // Should not flag blank lines around indented fenced code blocks
}

#[test]
fn test_md012_debug_indented_fenced() {
    let content = "Text\n\n    ```bash\n    code\n    ```\n\nMore text\n";
    let lines: Vec<&str> = content.lines().collect();

    // Debug the regions
    println!("Lines:");
    for (i, line) in lines.iter().enumerate() {
        println!("  {i}: {line:?}");
    }

    // Test the rule
    let rule = MD012NoMultipleBlanks::default();
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();

    println!("Warnings: {result:?}");
    for warning in &result {
        println!("  Line {}: {}", warning.line, warning.message);
    }

    // This should pass but currently fails
    assert!(result.is_empty(), "Expected no warnings, got: {result:?}");
}

#[test]
fn test_md012_contributing_pattern() {
    // This reproduces the exact pattern from the CONTRIBUTING file that's causing false positives
    let content = "To set up the MLflow repository, run the following commands:\n\n    ```bash\n    # Clone the repository\n    git clone --recurse-submodules git@github.com:<username>/mlflow.git\n    # The alternative way of cloning through https may cause permission error during branch push\n";

    let rule = MD012NoMultipleBlanks::default();
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();

    println!("Content lines:");
    for (i, line) in content.lines().enumerate() {
        println!("  {i}: {line:?}");
    }

    println!("Warnings: {result:?}");
    for warning in &result {
        println!("  Line {}: {}", warning.line, warning.message);
    }

    // This should pass - there's only 1 blank line before the indented fenced code block
    assert!(result.is_empty(), "Expected no warnings, got: {result:?}");
}

#[test]
fn test_md012_region_calculation() {
    // Test with a simple fenced code block to debug region calculation
    let content = "Text\n\n```bash\ncode\n```\n\nMore text\n";
    let lines: Vec<&str> = content.lines().collect();

    println!("Lines:");
    for (i, line) in lines.iter().enumerate() {
        println!("  {i}: {line:?}");
    }

    // We need to access the compute_code_block_regions function somehow
    // For now, let's just test the rule behavior
    let rule = MD012NoMultipleBlanks::default();
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();

    println!("Warnings: {result:?}");
    for warning in &result {
        println!("  Line {}: {}", warning.line, warning.message);
    }

    // This should pass - there's only 1 blank line before and after the code block
    assert!(result.is_empty(), "Expected no warnings, got: {result:?}");
}