flowmark 0.2.7

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::reformat_text;

#[test]
fn test_normal_width_wrapping() {
    let text = "This is a long line that should definitely be wrapped at narrow widths but fits on one line at wide widths.";

    // Test narrow width
    let result_40 =
        reformat_text(text, 40, true, false, false, false, false, ListSpacing::Preserve);
    let lines_40: Vec<&str> = result_40.lines().collect();
    assert!(lines_40.len() > 1, "Text should be wrapped at width 40");

    // Test wide width
    let result_200 =
        reformat_text(text, 200, true, false, false, false, false, ListSpacing::Preserve);
    let lines_200: Vec<&str> = result_200.lines().collect();
    assert_eq!(lines_200.len(), 1, "Text should fit on one line at width 200");
}

#[test]
fn test_zero_width_disables_wrapping() {
    let text = "This is a very long line that would normally be wrapped at any reasonable width setting but should remain as a single line when wrapping is disabled.";

    let result = reformat_text(text, 0, true, false, false, false, false, ListSpacing::Preserve);
    let lines: Vec<&str> = result.lines().collect();
    assert_eq!(lines.len(), 1, "Width 0 should disable wrapping and keep text on one line");
    assert_eq!(result.trim(), text, "Text should be unchanged except for whitespace normalization");
}

#[test]
fn test_width_zero_with_semantic() {
    let text = "This is sentence one. This is sentence two. This is sentence three.";

    let result = reformat_text(text, 0, true, true, false, false, false, ListSpacing::Preserve);
    let lines: Vec<&str> = result.lines().collect();
    assert_eq!(lines.len(), 1, "Width 0 with semantic should still keep text on one line");
}

#[test]
fn test_width_zero_with_markdown() {
    let text = "This is a long paragraph that would normally be wrapped but should remain on one line when width is 0.";

    let result = reformat_text(text, 0, false, false, false, false, false, ListSpacing::Preserve);
    let content = result.trim_end_matches('\n');
    let lines: Vec<&str> = content.split('\n').collect();
    assert_eq!(lines.len(), 1, "Width 0 with markdown should keep paragraph on one line");
}

#[test]
fn test_width_zero_with_markdown_semantic() {
    let text = "This is sentence one. This is sentence two. This is sentence three.";

    let result = reformat_text(text, 0, false, true, false, false, false, ListSpacing::Preserve);
    let content = result.trim_end_matches('\n');
    let lines: Vec<&str> = content.split('\n').collect();
    assert_eq!(lines.len(), 1, "Width 0 with markdown semantic should keep text on one line");
}

#[test]
fn test_existing_behavior_unchanged() {
    let text = "This is a test line that should be wrapped at the default width of 88 characters.";

    let result_default =
        reformat_text(text, 88, true, false, false, false, false, ListSpacing::Preserve);
    let result_88 =
        reformat_text(text, 88, true, false, false, false, false, ListSpacing::Preserve);
    assert_eq!(result_default, result_88, "Default behavior should match explicit width=88");

    let long_text = "This is a very long line that definitely exceeds 88 characters and should be wrapped when using the default width setting.";
    let result =
        reformat_text(long_text, 88, true, false, false, false, false, ListSpacing::Preserve);
    let lines: Vec<&str> = result.lines().collect();
    assert!(lines.len() > 1, "Long text should be wrapped at default width");
}

// ===== Tests ported from Python test_width_options.py =====

#[test]
fn test_negative_width_disables_wrapping() {
    // Python uses negative width (-1) to disable wrapping.
    // In Rust, width is usize (unsigned), so width=0 serves the same purpose.
    // This test verifies the Rust equivalent behavior.
    let text = "This is a very long line that would normally be wrapped at any reasonable width setting but should remain as a single line when wrapping is disabled.";

    let result = reformat_text(text, 0, true, false, false, false, false, ListSpacing::Preserve);
    let lines: Vec<&str> = result.lines().collect();
    assert_eq!(lines.len(), 1, "Width 0 should disable wrapping and keep text on one line");
    assert_eq!(result.trim(), text, "Text should be unchanged except for whitespace normalization");
}

/// H1 regression test: `fill_text` with width < indent length must not panic.
#[test]
fn test_very_small_width_does_not_panic() {
    use flowmark::fill_text;
    use flowmark::wrapping::text_filling::Wrap;

    // WrapIndent uses 4-char indent, width=2 would underflow without saturating_sub
    let result = fill_text("Hello world test", Wrap::WrapIndent, 2, "", "", 0, None);
    assert!(!result.is_empty(), "should produce output, not panic");

    // Also test fill_markdown with very small width on a nested list
    let result = reformat_text(
        "- Item one with some text\n  - Nested item\n",
        3,
        false,
        false,
        false,
        false,
        false,
        ListSpacing::Preserve,
    );
    assert!(!result.is_empty(), "fill_markdown with width=3 should not panic");
}