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

use version::Identifier;
use recognize::{Recognize, Alt, OneOrMore, Inclusive, OneByte};
use std::str::from_utf8;

// by the time we get here, we know that it's all valid characters, so this doesn't need to return
// a result or anything
fn parse_meta(s: &str) -> Vec<Identifier> {
    // Originally, I wanted to implement this method via calling parse, but parse is tolerant of
    // leading zeroes, and we want anything with leading zeroes to be considered alphanumeric, not
    // numeric. So the strategy is to check with a recognizer first, and then call parse once
    // we've determined that it's a number without a leading zero.
    s.split(".")
        .map(|part| {
            // another wrinkle: we made sure that any number starts with a
            // non-zero. But there's a problem: an actual zero is a number, yet
            // gets left out by this heuristic. So let's also check for the
            // single, lone zero.
            if is_alpha_numeric(part) {
                Identifier::AlphaNumeric(part.to_string())
            } else {
                // we can unwrap here because we know it is only digits due to the regex
                Identifier::Numeric(part.parse().unwrap())
            }
        }).collect()
}

// parse optional metadata (preceded by the prefix character)
pub fn parse_optional_meta(s: &[u8], prefix_char: u8)-> Result<(Vec<Identifier>, usize), String> {
    if let Some(len) = prefix_char.p(s) {
        let start = len;
        if let Some(len) = letters_numbers_dash_dot(&s[start..]) {
            let end = start + len;
            Ok((parse_meta(from_utf8(&s[start..end]).unwrap()), end))
        } else {
            Err("Error parsing prerelease".to_string())
        }
    } else {
        Ok((Vec::new(), 0))
    }
}

pub fn is_alpha_numeric(s: &str) -> bool {
    if let Some((_val, len)) = numeric_identifier(s.as_bytes()) {
        // Return true for number with leading zero
        // Note: doing it this way also handily makes overflow fail over.
        len != s.len()
    } else {
        true
    }
}

// Note: could plumb overflow error up to return value as Result
pub fn numeric_identifier(s: &[u8]) -> Option<(u64, usize)> {
    if let Some(len) = Alt(b'0', OneOrMore(Inclusive(b'0'..b'9'))).p(s) {
        from_utf8(&s[0..len]).unwrap().parse().ok().map(|val| (val, len))
    } else {
        None
    }
}

pub fn letters_numbers_dash_dot(s: &[u8]) -> Option<usize> {
    OneOrMore(OneByte(|c| c == b'-' || c == b'.' ||
        (b'0' <= c && c <= b'9') ||
        (b'a' <= c && c <= b'z') ||
        (b'A' <= c && c <= b'Z'))).p(s)
}