rumdl 0.1.88

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
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

use rumdl_lib::lint_context::LintContext;
use rumdl_lib::rule::Rule;
use rumdl_lib::rules::MD034NoBareUrls;

#[test]
fn test_ipv6_url_basic() {
    let rule = MD034NoBareUrls;
    let content = "Visit https://[::1]:8080 for local testing";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1, "IPv6 URL should be flagged as bare URL");
    assert_eq!(result[0].line, 1);

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "Visit <https://[::1]:8080> for local testing");
}

#[test]
fn test_ipv6_url_full_address() {
    let rule = MD034NoBareUrls;
    let content = "Server at http://[2001:db8::8a2e:370:7334]/path";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1, "Full IPv6 URL should be flagged");

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "Server at <http://[2001:db8::8a2e:370:7334]/path>");
}

#[test]
fn test_ipv6_localhost_variations() {
    let rule = MD034NoBareUrls;
    let test_cases = vec![
        ("http://[::1]", "<http://[::1]>"),
        ("https://[::1]", "<https://[::1]>"),
        ("http://[::1]:3000", "<http://[::1]:3000>"),
        ("https://[::1]:8080/api", "<https://[::1]:8080/api>"),
        ("http://[::ffff:127.0.0.1]", "<http://[::ffff:127.0.0.1]>"),
    ];

    for (input, expected) in test_cases {
        let ctx = LintContext::new(input, rumdl_lib::config::MarkdownFlavor::Standard, None);
        let result = rule.check(&ctx).unwrap();
        assert_eq!(result.len(), 1, "IPv6 URL '{input}' should be flagged");

        let fixed = rule.fix(&ctx).unwrap();
        assert_eq!(fixed, expected, "IPv6 URL '{input}' should be wrapped correctly");
    }
}

#[test]
fn test_ipv6_with_zone_id() {
    let rule = MD034NoBareUrls;
    let content = "Connect to https://[fe80::1%eth0]:8080";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1, "IPv6 with zone ID should be flagged");

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "Connect to <https://[fe80::1%eth0]:8080>");
}

#[test]
fn test_ipv6_mixed_with_ipv4() {
    let rule = MD034NoBareUrls;
    let content = "Try http://127.0.0.1 or https://[::1]:8080 or http://localhost";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 3, "All three URLs should be flagged");

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(
        fixed,
        "Try <http://127.0.0.1> or <https://[::1]:8080> or <http://localhost>"
    );
}

#[test]
fn test_ipv6_in_markdown_link() {
    let rule = MD034NoBareUrls;
    let content = "[IPv6 Server](https://[2001:db8::1]:8080) is already linked";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(result.is_empty(), "IPv6 URL in markdown link should not be flagged");
}

#[test]
fn test_ipv6_in_angle_brackets() {
    let rule = MD034NoBareUrls;
    let content = "Already wrapped: <https://[::1]:8080>";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(
        result.is_empty(),
        "IPv6 URL already in angle brackets should not be flagged"
    );
}

#[test]
fn test_ipv6_edge_cases() {
    let rule = MD034NoBareUrls;

    // Test compressed zeros
    let content = "Visit http://[2001:db8:0:0:0:0:0:1] or http://[2001:db8::1]";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 2, "Both IPv6 formats should be flagged");

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "Visit <http://[2001:db8:0:0:0:0:0:1]> or <http://[2001:db8::1]>");
}

#[test]
fn test_ipv6_with_path_query_fragment() {
    let rule = MD034NoBareUrls;
    let content = "API at https://[2001:db8::1]:8080/api/v1?param=value#section";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1, "IPv6 URL with full path should be flagged");

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "API at <https://[2001:db8::1]:8080/api/v1?param=value#section>");
}

#[test]
fn test_ipv6_trailing_punctuation() {
    let rule = MD034NoBareUrls;
    let content = "Visit https://[::1]:8080.";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1, "IPv6 URL with trailing period should be flagged");

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "Visit <https://[::1]:8080>.");
}

#[test]
fn test_ipv6_ftp_protocol() {
    let rule = MD034NoBareUrls;
    let content = "FTP server at ftp://[2001:db8::ftp]:21";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 1, "FTP IPv6 URL should be flagged");

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(fixed, "FTP server at <ftp://[2001:db8::ftp]:21>");
}

#[test]
fn test_ipv6_multiple_on_line() {
    let rule = MD034NoBareUrls;
    let content = "Primary: https://[2001:db8::1] Secondary: https://[2001:db8::2]";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert_eq!(result.len(), 2, "Both IPv6 URLs should be flagged");

    let fixed = rule.fix(&ctx).unwrap();
    assert_eq!(
        fixed,
        "Primary: <https://[2001:db8::1]> Secondary: <https://[2001:db8::2]>"
    );
}

#[test]
fn test_ipv6_in_reference_definition() {
    let rule = MD034NoBareUrls;
    let content = "[ref]: https://[::1]:8080";
    let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
    let result = rule.check(&ctx).unwrap();
    assert!(
        result.is_empty(),
        "IPv6 URL in reference definition should not be flagged"
    );
}

#[test]
fn test_ipv6_invalid_formats_not_flagged() {
    let rule = MD034NoBareUrls;
    // These are not valid URLs and should not be flagged
    let test_cases = vec![
        "Just brackets [::1] without protocol",
        "Missing closing bracket https://[::1:8080",
        "Missing opening bracket https://::1]:8080",
        "Empty brackets https://[]:8080",
    ];

    for content in test_cases {
        let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None);
        let result = rule.check(&ctx).unwrap();
        assert!(result.is_empty(), "Invalid format '{content}' should not be flagged");
    }
}