knott 0.0.1

Fast Rust package manager helper for Arch Linux repos and the AUR
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

use std::cmp::Ordering;

pub fn vercmp(left: &str, right: &str) -> Ordering {
    let (left_epoch, left_rest) = split_epoch(left);
    let (right_epoch, right_rest) = split_epoch(right);

    match left_epoch.cmp(&right_epoch) {
        Ordering::Equal => {}
        other => return other,
    }

    let (left_ver, left_rel) = split_release(left_rest);
    let (right_ver, right_rel) = split_release(right_rest);

    match compare_version_part(left_ver, right_ver) {
        Ordering::Equal => compare_version_part(left_rel.unwrap_or(""), right_rel.unwrap_or("")),
        other => other,
    }
}

fn split_epoch(value: &str) -> (u64, &str) {
    if let Some((epoch, rest)) = value.split_once(':') {
        (epoch.parse().unwrap_or(0), rest)
    } else {
        (0, value)
    }
}

fn split_release(value: &str) -> (&str, Option<&str>) {
    if let Some(index) = value.rfind('-') {
        (&value[..index], Some(&value[index + 1..]))
    } else {
        (value, None)
    }
}

fn compare_version_part(left: &str, right: &str) -> Ordering {
    let left = left.as_bytes();
    let right = right.as_bytes();
    let mut li = 0;
    let mut ri = 0;

    loop {
        while li < left.len() && !left[li].is_ascii_alphanumeric() {
            li += 1;
        }
        while ri < right.len() && !right[ri].is_ascii_alphanumeric() {
            ri += 1;
        }

        if li == left.len() || ri == right.len() {
            return left[li..].len().cmp(&right[ri..].len());
        }

        let left_digit = left[li].is_ascii_digit();
        let right_digit = right[ri].is_ascii_digit();

        if left_digit && right_digit {
            let l_start = li;
            let r_start = ri;
            while li < left.len() && left[li].is_ascii_digit() {
                li += 1;
            }
            while ri < right.len() && right[ri].is_ascii_digit() {
                ri += 1;
            }

            let l_trim = trim_zeroes(&left[l_start..li]);
            let r_trim = trim_zeroes(&right[r_start..ri]);
            match l_trim.len().cmp(&r_trim.len()) {
                Ordering::Equal => match l_trim.cmp(r_trim) {
                    Ordering::Equal => {}
                    other => return other,
                },
                other => return other,
            }
        } else if !left_digit && !right_digit {
            let l_start = li;
            let r_start = ri;
            while li < left.len() && left[li].is_ascii_alphabetic() {
                li += 1;
            }
            while ri < right.len() && right[ri].is_ascii_alphabetic() {
                ri += 1;
            }

            match left[l_start..li].cmp(&right[r_start..ri]) {
                Ordering::Equal => {}
                other => return other,
            }
        } else {
            return if left_digit {
                Ordering::Greater
            } else {
                Ordering::Less
            };
        }
    }
}

fn trim_zeroes(mut value: &[u8]) -> &[u8] {
    while value.first() == Some(&b'0') {
        value = &value[1..];
    }
    value
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn compares_numeric_segments() {
        assert_eq!(vercmp("1.10", "1.9"), Ordering::Greater);
        assert_eq!(vercmp("1.02", "1.2"), Ordering::Equal);
    }

    #[test]
    fn compares_epoch_before_version() {
        assert_eq!(vercmp("1:1.0", "2.0"), Ordering::Greater);
    }

    #[test]
    fn compares_pkgrel_after_pkgver() {
        assert_eq!(vercmp("1.0-2", "1.0-1"), Ordering::Greater);
    }
}