mdv 4.2.1

Terminal Markdown Viewer
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

use super::*;

#[test]
fn missing_footnote_show_renders_placeholder() {
    let temp_file = NamedTempFile::new().unwrap();
    fs::write(&temp_file, "```md\nIntro[^missing]\n```\n").unwrap();

    let mut cmd = mdv_cmd();
    cmd.arg("--no-colors")
        .arg("--cols")
        .arg("80")
        .arg("--missing-footnote-style")
        .arg("show")
        .arg(temp_file.path());

    let output = cmd.output().expect("run mdv with missing footnote");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("stdout is utf-8");

    let separator_count = stdout
        .lines()
        .filter(|line| line.trim_start().starts_with('◇'))
        .count();
    assert_eq!(
        separator_count, 1,
        "missing footnote should render a block: {}",
        stdout
    );
    assert!(
        stdout.contains("[^missing] Missing footnote definition"),
        "missing footnote placeholder should be rendered: {}",
        stdout
    );
}

#[test]
fn missing_footnote_in_plain_text_renders_placeholder() {
    let temp_file = NamedTempFile::new().unwrap();
    fs::write(&temp_file, "Intro[^missing]\n").unwrap();

    let mut cmd = mdv_cmd();
    cmd.arg("--no-colors")
        .arg("--cols")
        .arg("80")
        .arg("--missing-footnote-style")
        .arg("show")
        .arg(temp_file.path());

    let output = cmd
        .output()
        .expect("run mdv with missing footnote in plain text");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("stdout is utf-8");

    assert!(
        stdout.contains("[^missing] Missing footnote definition"),
        "missing footnote placeholder should be rendered: {}",
        stdout
    );
}

#[test]
fn missing_footnote_hide_omits_block() {
    let temp_file = NamedTempFile::new().unwrap();
    fs::write(&temp_file, "```md\nIntro[^missing]\n```\n").unwrap();

    let mut cmd = mdv_cmd();
    cmd.arg("--no-colors")
        .arg("--cols")
        .arg("80")
        .arg("--missing-footnote-style")
        .arg("hide")
        .arg(temp_file.path());

    let output = cmd.output().expect("run mdv with hidden missing footnote");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("stdout is utf-8");

    let separator_count = stdout
        .lines()
        .filter(|line| line.trim_start().starts_with('◇'))
        .count();
    assert_eq!(
        separator_count, 0,
        "missing footnote block should be omitted: {}",
        stdout
    );
    assert!(
        !stdout.contains("Missing footnote definition"),
        "placeholder should not be rendered when hidden: {}",
        stdout
    );
}

#[test]
fn missing_footnote_hide_omits_all_placeholder_messages() {
    let temp_file = NamedTempFile::new().unwrap();
    fs::write(&temp_file, "Intro[^missing]\n\n[^empty]:\n[^invalid]\n").unwrap();

    let mut cmd = mdv_cmd();
    cmd.arg("--no-colors")
        .arg("--cols")
        .arg("80")
        .arg("--missing-footnote-style")
        .arg("hide")
        .arg(temp_file.path());

    let output = cmd.output().expect("run mdv with hidden placeholders");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("stdout is utf-8");

    let separator_count = stdout
        .lines()
        .filter(|line| line.trim_start().starts_with('◇'))
        .count();
    assert_eq!(
        separator_count, 0,
        "placeholder footnotes should not render any block: {}",
        stdout
    );
    assert!(
        !stdout.contains("Missing footnote definition"),
        "missing placeholder should be hidden: {}",
        stdout
    );
    assert!(
        !stdout.contains("Invalid footnote syntax"),
        "invalid syntax placeholder should be hidden: {}",
        stdout
    );
    assert!(
        !stdout.contains("Empty footnote content"),
        "empty content placeholder should be hidden: {}",
        stdout
    );
}

#[test]
fn bare_footnote_definition_without_colon_reports_invalid_syntax() {
    let temp_file = NamedTempFile::new().unwrap();
    fs::write(&temp_file, "Intro[^a]\n\n[^a]\n").unwrap();

    let mut cmd = mdv_cmd();
    cmd.arg("--no-colors")
        .arg("--cols")
        .arg("80")
        .arg("--missing-footnote-style")
        .arg("show")
        .arg(temp_file.path());

    let output = cmd.output().expect("run mdv with bare footnote definition");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("stdout is utf-8");

    assert!(
        stdout.contains("Intro[^a]"),
        "reference should remain in text: {}",
        stdout
    );
    assert!(
        !stdout.lines().any(|line| line.trim().eq("[^a]")),
        "bare definition line should be removed from output: {}",
        stdout
    );
    assert!(
        stdout.contains("[^a] Invalid footnote syntax"),
        "invalid syntax message should be rendered: {}",
        stdout
    );
}

#[test]
fn empty_footnote_definition_reports_empty_body() {
    let temp_file = NamedTempFile::new().unwrap();
    fs::write(&temp_file, "Intro[^a]\n\n[^a]:\n").unwrap();

    let mut cmd = mdv_cmd();
    cmd.arg("--no-colors")
        .arg("--cols")
        .arg("80")
        .arg("--missing-footnote-style")
        .arg("show")
        .arg(temp_file.path());

    let output = cmd
        .output()
        .expect("run mdv with empty footnote definition");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("stdout is utf-8");

    assert!(
        stdout.contains("[^a] Empty footnote content"),
        "empty body message should be rendered: {}",
        stdout
    );
}

#[test]
fn markdown_code_block_definitions_match_normal_behavior() {
    let temp_file = NamedTempFile::new().unwrap();
    fs::write(
        &temp_file,
        "```md\nIntro[^a]\nIntro2[^b]\n[^a]\n[^b]:\n```\n",
    )
    .unwrap();

    let mut cmd = mdv_cmd();
    cmd.arg("--no-colors")
        .arg("--cols")
        .arg("80")
        .arg("--missing-footnote-style")
        .arg("show")
        .arg(temp_file.path());

    let output = cmd
        .output()
        .expect("run mdv with markdown code block footnotes");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("stdout is utf-8");

    assert!(
        stdout.contains("[^a] Invalid footnote syntax"),
        "invalid syntax in markdown code block should be reported: {}",
        stdout
    );
    assert!(
        stdout.contains("[^b] Empty footnote content"),
        "empty body in markdown code block should be reported: {}",
        stdout
    );
    assert!(
        !stdout.contains("Missing footnote definition"),
        "markdown code block definitions should not be treated as missing: {}",
        stdout
    );
}