formars-core 0.1.0

Typed schema primitives with a dyn-safe erased view for form validation.
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

/// Pragmatic email check: requires one `@` splitting non-empty local and
/// domain parts; domain must have a dotted suffix with alphanumeric labels.
/// NOT RFC 5322 — quoted locals, IP-literal domains and IDN are rejected.
/// For stricter needs use `.refine(|s| ..)` with a dedicated crate.
pub(crate) fn is_plausible_email(s: &str) -> bool {
    let Some((local, domain)) = s.split_once('@') else {
        return false;
    };
    if s.matches('@').count() != 1 || local.is_empty() || !domain.contains('.') {
        return false;
    }
    if s.chars().any(char::is_whitespace) {
        return false;
    }
    let labels: Vec<&str> = domain.split('.').collect();
    labels.len() >= 2
        && labels
            .iter()
            .all(|l| !l.is_empty() && l.chars().all(|c| c.is_ascii_alphanumeric() || c == '-'))
}

/// Pragmatic URL check: requires `scheme://` prefix, non-empty host, no
/// whitespace. NOT RFC 3986 — percent-encoding validity is not verified.
/// For stricter needs use `.refine(|s| ..)` with the `url` crate via refine.
pub(crate) fn is_plausible_url(s: &str) -> bool {
    let Some((scheme, rest)) = s.split_once("://") else {
        return false;
    };
    if scheme.is_empty()
        || !scheme
            .chars()
            .next()
            .is_some_and(|c| c.is_ascii_alphabetic())
    {
        return false;
    }
    if !scheme
        .chars()
        .all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '-' || c == '.')
    {
        return false;
    }
    let authority = rest.split(['/', '?', '#']).next().unwrap_or("");
    let host = authority.split(':').next().unwrap_or(authority);
    !host.is_empty() && !s.chars().any(char::is_whitespace)
}

/// Pragmatic UUID check: canonical 8-4-4-4-12 hex groups (case-insensitive).
/// Braced/urn forms are rejected in v0.
pub(crate) fn is_plausible_uuid(s: &str) -> bool {
    let groups: Vec<&str> = s.split('-').collect();
    if groups.len() != 5 || !groups.iter().map(|g| g.len()).eq([8usize, 4, 4, 4, 12]) {
        return false;
    }
    groups
        .iter()
        .all(|g| g.chars().all(|c| c.is_ascii_hexdigit()))
}

#[cfg(test)]
mod tests {
    use crate::validators::{is_plausible_email, is_plausible_url, is_plausible_uuid};

    #[test]
    fn email_fixture_table() {
        let accept = ["user@example.com", "a.b+tag@sub.domain.org", "x@y.co"];
        let reject = [
            "",
            "not-an-email",
            "@example.com",
            "user@",
            "user@@example.com",
            "user@example..com",
            "us er@example.com",
            "user@exa mple.com",
            "user@example.",
            "user@ex\u{e4}mple.com",
        ];
        for s in accept {
            assert!(is_plausible_email(s), "expected accept: {s}");
        }
        for s in reject {
            assert!(!is_plausible_email(s), "expected reject: {s}");
        }
    }

    #[test]
    fn url_fixture_table() {
        let accept = [
            "https://example.com",
            "http://example.com/path?query=1#frag",
            "https://sub.domain.org:8443/x",
            "ftp://files.example.org",
        ];
        let reject = [
            "",
            "example.com",
            "https://",
            "http:///path",
            "://example.com",
            "https://:8080/x",
        ];
        for s in accept {
            assert!(is_plausible_url(s), "expected accept: {s}");
        }
        for s in reject {
            assert!(!is_plausible_url(s), "expected reject: {s}");
        }
    }

    #[test]
    fn uuid_fixture_table() {
        let accept = [
            "123e4567-e89b-12d3-a456-426614174000",
            "00000000-0000-0000-0000-000000000000",
            "123E4567-E89B-12D3-A456-426614174000",
        ];
        let reject = [
            "",
            "123e4567e89b12d3a456426614174000",
            "123e4567-e89b-12d3-a456-42661417400g",
            "123e4567-e89b-12d3-a456",
            "zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz",
        ];
        for s in accept {
            assert!(is_plausible_uuid(s), "expected accept: {s}");
        }
        for s in reject {
            assert!(!is_plausible_uuid(s), "expected reject: {s}");
        }
    }
}