rumdl 0.1.51

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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322

use std::fs;
use std::process::Command;
use tempfile::tempdir;

fn setup_test_file() -> tempfile::TempDir {
    let temp_dir = tempdir().unwrap();
    let base_path = temp_dir.path();

    // Create a test file that will trigger multiple rules
    fs::write(
        base_path.join("test.md"),
        "# Test Header\n\n### Skip Level Header\n\nThis is a very long line that exceeds the typical line length limit for markdown files and should trigger MD013\n\n<html>HTML content</html>\n",
    )
    .unwrap();

    temp_dir
}

#[test]
fn test_enable_disable_precedence() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: --enable with --disable should have disable win
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args([
            "check",
            "test.md",
            "--enable",
            "MD001",
            "--disable",
            "MD001",
            "--verbose",
        ])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Enable+Disable output: {stdout}");

    // Should show no enabled rules (MD001 disabled)
    assert!(stdout.contains("Enabled rules:"));
    assert!(
        !stdout.contains("MD001"),
        "MD001 should be disabled when both --enable and --disable are specified"
    );
    assert!(output.status.success(), "Command should succeed with no issues");
}

#[test]
fn test_enable_only() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: --enable only should enable only specified rules
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args(["check", "test.md", "--enable", "MD001", "--verbose"])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Enable only output: {stdout}");

    // Should show only MD001 enabled
    assert!(stdout.contains("MD001"), "MD001 should be enabled");
    assert!(
        !stdout.contains("MD013"),
        "MD013 should not be enabled when only MD001 is specified"
    );
    assert!(
        !stdout.contains("MD033"),
        "MD033 should not be enabled when only MD001 is specified"
    );

    // Should detect the MD001 violation (skipping heading level)
    assert!(!output.status.success(), "Command should fail due to MD001 violation");
    assert!(stdout.contains("MD001"), "Should show MD001 violation in output");
}

#[test]
fn test_disable_only() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: --disable only should disable specified rules
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args(["check", "test.md", "--disable", "MD001", "--verbose"])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Disable only output: {stdout}");

    // Should show all rules except MD001
    assert!(!stdout.contains("MD001 (Heading levels"), "MD001 should be disabled");
    assert!(stdout.contains("MD013"), "MD013 should be enabled");
    assert!(stdout.contains("MD033"), "MD033 should be enabled");

    // Should detect violations but not MD001
    let stderr = String::from_utf8_lossy(&output.stderr);
    let combined_output = format!("{stdout}{stderr}");
    assert!(!combined_output.contains("MD001"), "Should not report MD001 violations");
}

#[test]
fn test_extend_enable() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: --extend-enable should add rules to default set
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args(["check", "test.md", "--extend-enable", "MD001", "--verbose"])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Extend enable output: {stdout}");

    // Should show all default rules plus MD001
    assert!(stdout.contains("MD001"), "MD001 should be enabled via extend-enable");
    assert!(
        stdout.contains("MD013"),
        "MD013 should still be enabled (default behavior)"
    );
    assert!(
        stdout.contains("MD033"),
        "MD033 should still be enabled (default behavior)"
    );
}

#[test]
fn test_extend_disable() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: --extend-disable should remove rules from default set
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args(["check", "test.md", "--extend-disable", "MD001", "--verbose"])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Extend disable output: {stdout}");

    // Should show all default rules except MD001
    assert!(
        !stdout.contains("MD001 (Heading levels"),
        "MD001 should be disabled via extend-disable"
    );
    assert!(stdout.contains("MD013"), "MD013 should still be enabled");
    assert!(stdout.contains("MD033"), "MD033 should still be enabled");
}

#[test]
fn test_multiple_rules() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: Multiple rules in enable/disable
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args([
            "check",
            "test.md",
            "--enable",
            "MD001,MD013",
            "--disable",
            "MD013",
            "--verbose",
        ])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Multiple rules output: {stdout}");

    // Should show only MD001 enabled (MD013 disabled by --disable)
    assert!(stdout.contains("MD001"), "MD001 should be enabled");
    assert!(!stdout.contains("MD013"), "MD013 should be disabled by --disable flag");
    assert!(
        !stdout.contains("MD033"),
        "MD033 should not be enabled when only MD001,MD013 specified"
    );
}

#[test]
fn test_extend_flags_with_disable() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: --extend-enable with --disable should have disable win
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args([
            "check",
            "test.md",
            "--extend-enable",
            "MD001",
            "--disable",
            "MD001",
            "--verbose",
        ])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Extend enable with disable output: {stdout}");

    // Should show all default rules except MD001 (disabled by --disable)
    assert!(
        !stdout.contains("MD001 (Heading levels"),
        "MD001 should be disabled by --disable even when extended"
    );
    assert!(stdout.contains("MD013"), "MD013 should still be enabled");
    assert!(stdout.contains("MD033"), "MD033 should still be enabled");
}

#[test]
fn test_case_insensitive_rules() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: Case insensitive rule names
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args([
            "check",
            "test.md",
            "--enable",
            "md001",
            "--disable",
            "MD001",
            "--verbose",
        ])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Case insensitive output: {stdout}");

    // Should work with case insensitive matching
    assert!(
        !stdout.contains("MD001 (Heading levels"),
        "MD001 should be disabled even with case mismatch"
    );
    assert!(output.status.success(), "Command should succeed with no issues");
}

#[test]
fn test_flag_combinations() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Test: Complex flag combination
    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args([
            "check",
            "test.md",
            "--extend-enable",
            "MD001",
            "--extend-disable",
            "MD013",
            "--disable",
            "MD033",
            "--verbose",
        ])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Complex combination output: {stdout}");

    // Should show: all default rules + MD001 - MD013 - MD033
    assert!(stdout.contains("MD001"), "MD001 should be enabled via extend-enable");
    assert!(!stdout.contains("MD013"), "MD013 should be disabled via extend-disable");
    assert!(!stdout.contains("MD033"), "MD033 should be disabled via --disable");
}

#[test]
fn test_enable_overrides_config_extend_enable_all() {
    let temp_dir = setup_test_file();
    let base_path = temp_dir.path();
    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");

    // Config enables all rules, but explicit CLI --enable should override selection.
    fs::write(base_path.join("rumdl.toml"), "[global]\nextend-enable = [\"ALL\"]\n").unwrap();

    let output = Command::new(rumdl_exe)
        .current_dir(base_path)
        .args(["check", "test.md", "--enable", "MD001", "--verbose"])
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout);
    println!("Enable over extend-enable=ALL output: {stdout}");

    assert!(stdout.contains("MD001"), "MD001 should be enabled");
    assert!(
        !stdout.contains("MD013"),
        "MD013 should not be enabled when CLI --enable selects only MD001"
    );
    assert!(
        !stdout.contains("MD033"),
        "MD033 should not be enabled when CLI --enable selects only MD001"
    );
    assert!(!output.status.success(), "Command should fail due to MD001 violation");
}