version-ranges 0.1.3

Performance-optimized type for generic version ranges and operations on them.
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

use semver::{Version, VersionReq};

use crate::Ranges;

/// Follows the specifications in [`semver::Op`].
fn ranges_exact(major: u64, minor: Option<u64>, patch: Option<u64>) -> Ranges<Version> {
    match (minor, patch) {
        (None, None) => ranges_greater_eq(major, Some(0), Some(0)).intersection(&ranges_less(
            major + 1,
            Some(0),
            Some(0),
        )),
        (None, Some(_)) => panic!("invalid version requirement"),
        (Some(minor), None) => ranges_greater_eq(major, Some(minor), Some(0))
            .intersection(&ranges_less(major, Some(minor + 1), Some(0))),
        (Some(minor), Some(patch)) => Ranges::singleton(Version::new(major, minor, patch)),
    }
}

/// Follows the specifications in [`semver::Op`].
fn ranges_greater(major: u64, minor: Option<u64>, patch: Option<u64>) -> Ranges<Version> {
    match (minor, patch) {
        (None, None) => ranges_greater_eq(major + 1, Some(0), Some(0)),
        (None, Some(_)) => panic!("invalid version requirement"),
        (Some(minor), None) => ranges_greater_eq(major, Some(minor + 1), Some(0)),
        (Some(minor), Some(patch)) => {
            Ranges::strictly_higher_than(Version::new(major, minor, patch))
        }
    }
}

/// Follows the specifications in [`semver::Op`].
fn ranges_greater_eq(major: u64, minor: Option<u64>, patch: Option<u64>) -> Ranges<Version> {
    Ranges::higher_than(Version::new(major, minor.unwrap_or(0), patch.unwrap_or(0)))
}

/// Follows the specifications in [`semver::Op`].
fn ranges_less(major: u64, minor: Option<u64>, patch: Option<u64>) -> Ranges<Version> {
    Ranges::strictly_lower_than(Version::new(major, minor.unwrap_or(0), patch.unwrap_or(0)))
}

/// Follows the specifications in [`semver::Op`].
fn ranges_less_eq(major: u64, minor: Option<u64>, patch: Option<u64>) -> Ranges<Version> {
    match (minor, patch) {
        (None, None) => ranges_less(major + 1, Some(0), Some(0)),
        (None, Some(_)) => panic!("invalid version requirement"),
        (Some(minor), None) => ranges_less(major, Some(minor + 1), Some(0)),
        (Some(minor), Some(patch)) => Ranges::lower_than(Version::new(major, minor, patch)),
    }
}

/// Follows the specifications in [`semver::Op`].
fn ranges_tilde(major: u64, minor: Option<u64>, patch: Option<u64>) -> Ranges<Version> {
    match (minor, patch) {
        (None, None) => ranges_exact(major, None, None),
        (None, Some(_)) => panic!("invalid version requirement"),
        (Some(minor), None) => ranges_exact(major, Some(minor), None),
        (Some(minor), Some(patch)) => ranges_greater_eq(major, Some(minor), Some(patch))
            .intersection(&ranges_less(major, Some(minor + 1), Some(0))),
    }
}

/// Follows the specifications in [`semver::Op`].
fn ranges_caret(major: u64, minor: Option<u64>, patch: Option<u64>) -> Ranges<Version> {
    match (major, minor, patch) {
        (major, Some(minor), Some(patch)) if major > 0 => ranges_greater_eq(
            major,
            Some(minor),
            Some(patch),
        )
        .intersection(&ranges_less(major + 1, Some(0), Some(0))),

        (0, Some(minor), Some(patch)) if minor > 0 => ranges_greater_eq(
            0,
            Some(minor),
            Some(patch),
        )
        .intersection(&ranges_less(0, Some(minor + 1), Some(0))),

        (0, Some(0), Some(patch)) => ranges_exact(0, Some(0), Some(patch)),

        (major, Some(minor), None) if major > 0 || minor > 0 => {
            ranges_caret(major, Some(minor), Some(0))
        }

        (0, Some(0), None) => ranges_exact(0, Some(0), None),

        (major, None, None) => ranges_exact(major, None, None),

        (_, _, _) => unreachable!(),
    }
}

/// Follows the specifications in [`semver::Op`].
fn ranges_wildcard(major: u64, minor: Option<u64>, _patch: Option<u64>) -> Ranges<Version> {
    match minor {
        Some(minor) => ranges_exact(major, Some(minor), None),
        None => ranges_exact(major, None, None),
    }
}

impl Ranges<Version> {
    /// Convert from a semver version requirement.
    ///
    /// Note that this is not a lossless conversion.
    /// Semver additionally require the `VersionReq` to contain prereleases for versions with prereleases to be matched.
    /// Therefore the `Ranges` constraint after conversion will be **looser** than original as it does only interval arithmetics based on ordering of versions.
    ///
    /// The behavior is undefined unless all major, minor and patch numbers in `VersionReq` are less than `u64::MAX` due to integer overflow.
    pub fn from_req(req: VersionReq) -> Self {
        let mut ranges = Ranges::full();
        for cmp in req.comparators {
            let new = match cmp.op {
                semver::Op::Exact => ranges_exact(cmp.major, cmp.minor, cmp.patch),
                semver::Op::Greater => ranges_greater(cmp.major, cmp.minor, cmp.patch),
                semver::Op::GreaterEq => ranges_greater_eq(cmp.major, cmp.minor, cmp.patch),
                semver::Op::Less => ranges_less(cmp.major, cmp.minor, cmp.patch),
                semver::Op::LessEq => ranges_less_eq(cmp.major, cmp.minor, cmp.patch),
                semver::Op::Tilde => ranges_tilde(cmp.major, cmp.minor, cmp.patch),
                semver::Op::Caret => ranges_caret(cmp.major, cmp.minor, cmp.patch),
                semver::Op::Wildcard => ranges_wildcard(cmp.major, cmp.minor, cmp.patch),
                _ => unimplemented!(),
            };
            ranges = ranges.intersection(&new);
        }
        ranges
    }
}