rumdl 0.1.82

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 assert_cmd::cargo::cargo_bin_cmd;
use std::fs;
use tempfile::tempdir;

/// Test that `rumdl import` does not generate a trailing blank line in the output file.
/// Regression test for https://github.com/rvben/rumdl/issues/433
#[test]
fn test_import_no_trailing_blank_line_in_file() {
    let temp_dir = tempdir().expect("Failed to create temporary directory");

    let input = temp_dir.path().join("input.json");
    fs::write(&input, r#"{"MD003": {"style": "atx"}, "MD046": {"style": "fenced"}}"#).expect("Failed to write input");

    let output = temp_dir.path().join("output.toml");

    let mut cmd = cargo_bin_cmd!("rumdl");
    cmd.arg("import")
        .arg(input.to_str().unwrap())
        .arg("--output")
        .arg(output.to_str().unwrap());

    cmd.assert().success();

    let content = fs::read_to_string(&output).expect("Failed to read output");

    // File must end with exactly one newline, not a blank line
    assert!(
        content.ends_with('\n'),
        "Output file should end with a newline, got: {content:?}"
    );
    assert!(
        !content.ends_with("\n\n"),
        "Output file should not have a trailing blank line, got: {content:?}"
    );
}

/// Test that `rumdl import --dry-run` does not produce a trailing blank line.
#[test]
fn test_import_dry_run_no_trailing_blank_line() {
    let temp_dir = tempdir().expect("Failed to create temporary directory");

    let input = temp_dir.path().join("input.json");
    fs::write(&input, r#"{"MD003": {"style": "atx"}, "MD046": {"style": "fenced"}}"#).expect("Failed to write input");

    let mut cmd = cargo_bin_cmd!("rumdl");
    cmd.arg("import").arg(input.to_str().unwrap()).arg("--dry-run");

    let output = cmd.output().expect("Failed to execute command");
    let stdout = String::from_utf8_lossy(&output.stdout);

    assert!(
        stdout.ends_with('\n'),
        "Dry-run output should end with a newline, got: {stdout:?}"
    );
    assert!(
        !stdout.ends_with("\n\n"),
        "Dry-run output should not have a trailing blank line, got: {stdout:?}"
    );
}

/// Test that `rumdl import --format json --dry-run` does not produce a trailing blank line.
/// Regression: changing println! to print! in dry-run broke JSON output (no trailing newline).
#[test]
fn test_import_json_dry_run_no_trailing_blank_line() {
    let temp_dir = tempdir().expect("Failed to create temporary directory");

    let input = temp_dir.path().join("input.json");
    fs::write(&input, r#"{"MD003": {"style": "atx"}}"#).expect("Failed to write input");

    let mut cmd = cargo_bin_cmd!("rumdl");
    cmd.arg("import")
        .arg(input.to_str().unwrap())
        .arg("--format")
        .arg("json")
        .arg("--dry-run");

    let output = cmd.output().expect("Failed to execute command");
    let stdout = String::from_utf8_lossy(&output.stdout);

    assert!(
        stdout.ends_with('\n'),
        "JSON dry-run output should end with a newline, got: {stdout:?}"
    );
    assert!(
        !stdout.ends_with("\n\n"),
        "JSON dry-run output should not have a trailing blank line, got: {stdout:?}"
    );
}

/// Test that sections are still separated by blank lines (formatting preserved).
#[test]
fn test_import_sections_separated_by_blank_lines() {
    let temp_dir = tempdir().expect("Failed to create temporary directory");

    let input = temp_dir.path().join("input.json");
    fs::write(&input, r#"{"MD003": {"style": "atx"}, "MD046": {"style": "fenced"}}"#).expect("Failed to write input");

    let mut cmd = cargo_bin_cmd!("rumdl");
    cmd.arg("import").arg(input.to_str().unwrap()).arg("--dry-run");

    let output = cmd.output().expect("Failed to execute command");
    let stdout = String::from_utf8_lossy(&output.stdout);

    // Both rule sections should appear
    assert!(stdout.contains("[MD003]"), "Output should contain [MD003] section");
    assert!(stdout.contains("[MD046]"), "Output should contain [MD046] section");

    // There should be a blank line between sections (before each non-first header)
    assert!(
        stdout.contains("\n\n[MD046]"),
        "Output should have blank lines between sections, got: {stdout:?}"
    );
}

#[test]
fn test_import_jsonc_with_comments() {
    let temp_dir = tempdir().expect("Failed to create temporary directory");

    let input = temp_dir.path().join("input.jsonc");
    fs::write(
        &input,
        r#"{
  // markdownlint-style comment
  "MD013": false
}"#,
    )
    .expect("Failed to write input");

    let mut cmd = cargo_bin_cmd!("rumdl");
    cmd.arg("import").arg(input.to_str().unwrap()).arg("--dry-run");

    cmd.assert()
        .success()
        .stdout(predicates::str::contains("disable = [\"MD013\"]"));
}