flowmark 0.3.1

A Markdown auto-formatter for clean diffs and semantic line breaks
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

use flowmark::config::ListSpacing;
use flowmark::fill_markdown;
use std::path::Path;

fn read_normalized(path: &Path) -> String {
    std::fs::read_to_string(path)
        .unwrap_or_else(|_| panic!("Failed to read: {}", path.display()))
        .replace("\r\n", "\n")
}

#[allow(clippy::struct_excessive_bools)]
struct TestCase {
    name: &'static str,
    filename: &'static str,
    semantic: bool,
    cleanups: bool,
    smartquotes: bool,
    ellipses: bool,
}

#[test]
fn test_reference_doc_formats() {
    let testdoc_dir = Path::new("tests/testdocs");
    let orig_path = testdoc_dir.join("testdoc.orig.md");

    assert!(orig_path.exists(), "Original test document not found at {orig_path:?}");

    let orig_content = read_normalized(&orig_path);

    let test_cases = [
        TestCase {
            name: "plain",
            filename: "testdoc.expected.plain.md",
            semantic: false,
            cleanups: false,
            smartquotes: false,
            ellipses: false,
        },
        TestCase {
            name: "semantic",
            filename: "testdoc.expected.semantic.md",
            semantic: true,
            cleanups: false,
            smartquotes: false,
            ellipses: false,
        },
        TestCase {
            name: "cleaned",
            filename: "testdoc.expected.cleaned.md",
            semantic: true,
            cleanups: true,
            smartquotes: false,
            ellipses: false,
        },
        TestCase {
            name: "auto",
            filename: "testdoc.expected.auto.md",
            semantic: true,
            cleanups: true,
            smartquotes: true,
            ellipses: true,
        },
    ];

    let mut all_pass = true;
    for case in &test_cases {
        let test_doc = testdoc_dir.join(case.filename);
        let expected = read_normalized(&test_doc);

        let actual = fill_markdown(
            &orig_content,
            true,
            88,
            case.semantic,
            case.cleanups,
            case.smartquotes,
            case.ellipses,
            None,
            ListSpacing::Preserve,
        );

        if actual != expected {
            let actual_path = testdoc_dir.join(format!("testdoc.actual.{}.md", case.name));
            std::fs::write(&actual_path, &actual)
                .unwrap_or_else(|_| panic!("Failed to write actual output for {}", case.name));
            eprintln!("actual was different from expected for {}!", case.name);
            eprintln!("Saving actual to: {actual_path:?}");

            // Show first difference
            let expected_lines: Vec<&str> = expected.lines().collect();
            let actual_lines: Vec<&str> = actual.lines().collect();
            for (i, (exp, act)) in expected_lines.iter().zip(actual_lines.iter()).enumerate() {
                if exp != act {
                    eprintln!("First difference at line {} for {}:", i + 1, case.name);
                    eprintln!("  Expected: {exp:?}");
                    eprintln!("  Actual:   {act:?}");
                    break;
                }
            }
            if expected_lines.len() != actual_lines.len() {
                eprintln!(
                    "Line count differs for {}: expected {}, got {}",
                    case.name,
                    expected_lines.len(),
                    actual_lines.len()
                );
            }

            all_pass = false;
        }
    }

    assert!(all_pass, "One or more reference document format tests failed");
}