rdftk_iri 0.1.0

Another implementation of the IRI/URI specifications
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

/*!
Internal parsing functions.
*/

// ------------------------------------------------------------------------------------------------
// Public Functions
// ------------------------------------------------------------------------------------------------

pub(crate) fn is_scheme(s: &str) -> bool {
    // From RFC-2396, appendix A. _Collected BNF for URI_:
    // scheme = alpha *( alpha | digit | '+' | '-' | '.' )
    !s.is_empty()
        && s.starts_with(|c: char| c.is_alphabetic())
        && s[1..]
            .chars()
            .all(|c| c.is_alphanumeric() || c == '+' || c == '-' || c == '.')
}

pub(crate) fn is_ihost(s: &str) -> bool {
    // ihost          = IP-literal / IPv4address / ireg-name
    // IPv4address    = dec-octet "." dec-octet "." dec-octet "." dec-octet
    // IP-literal     = "[" ( IPv6address / IPvFuture  ) "]"
    // IPvFuture      = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
    // IPv6address    = /* +HEXDIG / ":" */
    // ireg-name      = *( iunreserved / pct-encoded / sub-delims )
    s.is_empty()
        || (s.chars().all(|c| {
            is_iunreserved(c) || is_sub_delims(c) || c == '[' || c == ']' || c == ':' || c == '.'
        }) && is_correctly_escaped(s))
}

pub(crate) fn is_iuserinfo(s: &str) -> bool {
    s.is_empty()
        || (s.chars().all(|c| is_iunreserved(c) || is_sub_delims(c)) && is_correctly_escaped(s))
}

// pub(crate) fn is_port(s: &str) -> bool {
//     s.chars().all(|c| c.is_ascii_digit())
// }

pub(crate) fn is_path(s: &str) -> bool {
    s.split('/').all(is_path_segment)
}

pub(crate) fn is_path_segment(s: &str) -> bool {
    let parts = s.split(';').collect::<Vec<&str>>();
    if parts.len() > 2 {
        false
    } else {
        parts
            .iter()
            .all(|s| s.is_empty() || s.chars().all(is_ipchar) && is_correctly_escaped(s))
    }
}

pub(crate) fn is_iquery(s: &str) -> bool {
    s.is_empty()
        || (s
            .chars()
            .all(|c| is_ipchar(c) || is_iprivate(c) || c == '/' || c == '?')
            && is_correctly_escaped(s))
}

pub(crate) fn is_ifragment(s: &str) -> bool {
    s.is_empty()
        || (s.chars().all(|c| is_ipchar(c) || c == '/' || c == '?') && is_correctly_escaped(s))
}

// ------------------------------------------------------------------------------------------------

pub(crate) fn is_correctly_escaped(s: &str) -> bool {
    let chars = &s.chars().collect::<Vec<char>>();
    for window in chars.windows(3) {
        if window[0] == '%' && !(window[1].is_ascii_hexdigit() && window[2].is_ascii_hexdigit()) {
            return false;
        }
    }
    true
}

#[inline]
pub(crate) fn is_ipchar(c: char) -> bool {
    is_iunreserved(c) || is_sub_delims(c) || c == ':' || c == '@'
}

// #[inline]
// pub(crate) fn is_uric(c: char) -> bool {
//     is_reserved(c) || is_unreserved(c) // || is_escaped
// }

// #[inline]
// pub(crate) fn is_reserved(c: char) -> bool {
//     is_gen_delims(c) || is_sub_delims(c)
// }

// #[inline]
// pub(crate) fn is_gen_delims(c: char) -> bool {
//     c == ':' || c == '/' || c == '?' || c == '#' || c == '[' || c == ']' || c == '@'
// }

#[inline]
pub(crate) fn is_sub_delims(c: char) -> bool {
    c == '!'
        || c == '$'
        || c == '&'
        || c == '\''
        || c == '('
        || c == ')'
        || c == '*'
        || c == '+'
        || c == ','
        || c == ';'
        || c == '='
}

#[inline]
pub(crate) fn is_iunreserved(c: char) -> bool {
    is_unreserved(c) || is_ucschar(c)
}

#[inline]
pub(crate) fn is_unreserved(c: char) -> bool {
    c.is_ascii_alphanumeric() || c == '-' || c == '.' || c == '_' || c == '~'
}

#[inline]
pub(crate) fn is_ucschar(c: char) -> bool {
    c >= '\u{00A0}' && c <= '\u{D7FF}'
        || c >= '\u{F900}' && c <= '\u{FDCF}'
        || c >= '\u{FDF0}' && c <= '\u{FFEF}'
        || c >= '\u{10000}' && c <= '\u{1FFFD}'
        || c >= '\u{20000}' && c <= '\u{2FFFD}'
        || c >= '\u{30000}' && c <= '\u{3FFFD}'
        || c >= '\u{40000}' && c <= '\u{4FFFD}'
        || c >= '\u{50000}' && c <= '\u{5FFFD}'
        || c >= '\u{60000}' && c <= '\u{6FFFD}'
        || c >= '\u{70000}' && c <= '\u{7FFFD}'
        || c >= '\u{80000}' && c <= '\u{8FFFD}'
        || c >= '\u{90000}' && c <= '\u{9FFFD}'
        || c >= '\u{A0000}' && c <= '\u{AFFFD}'
        || c >= '\u{B0000}' && c <= '\u{BFFFD}'
        || c >= '\u{C0000}' && c <= '\u{CFFFD}'
        || c >= '\u{D0000}' && c <= '\u{DFFFD}'
        || c >= '\u{E0000}' && c <= '\u{EFFFD}'
}

#[inline]
pub(crate) fn is_iprivate(c: char) -> bool {
    c >= '\u{E000}' && c <= '\u{F8FF}'
        || c >= '\u{F0000}' && c <= '\u{FFFFD}'
        || c >= '\u{100000}' && c <= '\u{10FFFD}'
}