mdtablefix 0.6.1

`mdtablefix` unb0rks and reflows Markdown tables so that each column has a uniform width. When the `--wrap` option is used, it also wraps paragraphs and list items to 80 columns.
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

//! `wrap_text` tests covering inline GFM footnote-reference handling.

use mdtablefix::wrap::wrap_text;
use rstest::rstest;

/// Keep the pre-split snapshot layout: file names live in `tests/snapshots/`
/// and use the legacy `wrap_unit__<name>` prefix without the module
/// component, so existing reviewed snapshots remain authoritative.
macro_rules! footnote_snapshot {
    ($name:expr, $value:expr) => {
        insta::with_settings!(
            {
                snapshot_path => "../snapshots",
                prepend_module_to_snapshot => false,
            },
            { insta::assert_snapshot!($name, $value) }
        );
    };
}

fn assert_footnote_reference_is_intact(output: &[String], marker: &str) {
    let rendered = output.join("\n");
    assert!(rendered.contains(marker));
    assert!(!rendered.contains("[\n"));
    assert!(!rendered.contains("\n^"));
    assert!(!rendered.contains(".\n["));
    assert!(!rendered.contains(".\n ["));
}

#[rstest]
#[case("[^4]")]
#[case("[^25]")]
#[case("[^note]")]
fn wrap_text_preserves_inline_footnote_references(#[case] marker: &str) {
    let input = lines_vec![format!(
        concat!(
            "This sentence has enough preceding text to make the formatter choose ",
            "a bad wrap point near this reference ",
            "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.",
            "{} This sentence follows the reference marker.",
        ),
        marker,
    )];

    let wrapped = wrap_text(&input, 80);

    assert_footnote_reference_is_intact(&wrapped, marker);
    assert!(
        wrapped
            .iter()
            .any(|line| line.contains(&format!(".{marker}")))
    );
}

#[test]
fn wrap_text_snapshots_inline_footnote_reference_outputs() {
    let input = lines_vec![concat!(
        "This sentence has enough preceding text to make the formatter choose ",
        "a bad wrap point near this reference ",
        "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.",
        "[^4] This sentence follows the reference marker.",
    )];

    footnote_snapshot!(
        "inline_footnote_reference_wrap",
        wrap_text(&input, 80).join("\n")
    );
}

#[rstest]
#[case(".", "Word.[^1]")]
#[case(",", "Word,[^1]")]
#[case(";", "Word;[^1]")]
#[case(":", "Word:[^1]")]
#[case("?", "Word?[^1]")]
#[case("!", "Word![^1]")]
#[case(")", "Word)[^1]")]
#[case("\"", "Word\"[^1]")]
fn wrap_text_removes_spacing_between_punctuation_and_footnote_ref(
    #[case] punctuation: &str,
    #[case] expected: &str,
) {
    let input = lines_vec![format!("Word{punctuation} [^1]")];

    assert_eq!(wrap_text(&input, 80), lines_vec![expected]);
}

#[rstest]
#[case(lines_vec!["Word.", "[^1]"])]
#[case(lines_vec!["Word.", "  [^1]"])]
fn wrap_text_normalizes_split_footnote_refs_in_same_paragraph(#[case] input: Vec<String>) {
    assert_eq!(wrap_text(&input, 80), lines_vec!["Word.[^1]"]);
}

#[test]
fn wrap_text_keeps_punctuation_and_footnote_ref_attached_at_boundary() {
    let input = lines_vec![concat!(
        "This is a long sentence that eventually ends with a citation. [^7] ",
        "The next sentence gives the wrapper somewhere else to break.",
    )];

    let wrapped = wrap_text(&input, 54);
    let rendered = wrapped.join("\n");

    assert!(rendered.contains("citation.[^7]"));
    assert!(!rendered.contains("citation.\n[^7]"));
    assert!(!rendered.contains("citation.\n [^7]"));

    footnote_snapshot!("inline_footnote_reference_boundary_wrap", rendered);
}

#[test]
fn wrap_text_preserves_footnote_definition_lines() {
    let input = lines_vec!["[^1]: This is a definition."];

    assert_eq!(wrap_text(&input, 80), input);
}

#[test]
fn wrap_text_preserves_definition_after_blank_line() {
    let input = lines_vec!["Word.", "", "[^1]: This is a definition."];

    assert_eq!(wrap_text(&input, 80), input);
}

#[rstest]
#[case(
    concat!(
        "To assert specific outcomes, use the standard macros `assert!`, `assert_eq!`, and ",
        "`assert_ne!`.[^3] This sentence follows the reference marker.",
    ),
    "[^3]",
    "`assert_ne!`.[^3]",
    "inline_footnote_reference_after_code_wrap"
)]
#[case(
    concat!(
        "See the standard macros (`assert!`, `assert_eq!`, and `assert_ne!`).[^3] ",
        "This sentence follows the reference marker.",
    ),
    "[^3]",
    "`assert_ne!`).[^3]",
    "inline_footnote_reference_after_opener_coupled_code_wrap"
)]
fn wrap_text_keeps_footnote_reference_with_preceding_atomic_span(
    #[case] paragraph: &str,
    #[case] marker: &str,
    #[case] expected_snippet: &str,
    #[case] snapshot_name: &str,
) {
    let input = lines_vec![paragraph];
    let wrapped = wrap_text(&input, 80);

    assert_footnote_reference_is_intact(&wrapped, marker);
    assert!(wrapped.iter().any(|line| line.contains(expected_snippet)));

    footnote_snapshot!(snapshot_name, wrapped.join("\n"));
}