what-version-core 0.2.1

Determines the highest semver version from a list of versions that satisfies all given version requirements.
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

use semver::{Version, VersionReq};
use std::collections::HashSet;
use std::error::Error;
use std::fmt::{self, Display};

#[derive(Debug)]
pub struct NoValidVersion;

impl Display for NoValidVersion {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "No Valid Version")
    }
}

impl Error for NoValidVersion {}

/// Determines the highest version from a list of versions that satisfies all given version requirements.
///
/// ## Arguments
///
/// * `version_requirements` - A `HashSet` of `VersionReq` specifying the version constraints.
/// * `versions` - A `Vec` of `Version` representing the available versions to choose from.
///
/// ## Returns
///
/// * `Ok(Version)` - The highest version that satisfies all the given requirements.
/// * `Err(())` - If no version satisfies all the given requirements.
///
/// ## Examples
///
/// ```rust
/// use std::collections::HashSet;
/// use semver::{Version, VersionReq};
/// use what_version_core::what_version;
///
/// let version_requirements: HashSet<VersionReq> = vec![
///     "^2.0".parse().unwrap(),
///     ">=2.1".parse().unwrap(),
///     "<2.3".parse().unwrap(),
/// ]
/// .into_iter()
/// .collect();
///
/// let versions: Vec<Version> = vec![
///     "2.5.1", "2.5.0", "2.4.0", "2.3.0", "2.2.0", "2.1.1", "2.1.0", "2.0.2", "2.0.1", "2.0.0",
/// ]
/// .into_iter()
/// .map(|ver| ver.parse().unwrap())
/// .collect();
///
/// let result = what_version(version_requirements, versions);
///
/// assert_eq!(result.unwrap(), Version::parse("2.2.0").unwrap());
/// ```
pub fn what_version(
    version_requirements: HashSet<VersionReq>,
    versions: Vec<Version>,
) -> Result<Version, NoValidVersion> {
    versions
        .iter()
        .filter(|ver| version_requirements.iter().all(|req| req.matches(ver)))
        .max_by(|arg0: &&semver::Version, other: &&semver::Version| {
            Version::cmp_precedence(arg0, other)
        })
        .cloned()
        .ok_or(NoValidVersion)
}

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

    const VERSIONS: [&str; 14] = [
        "2.5.1", "2.5.0", "2.4.0", "2.3.0", "2.2.0", "2.1.1", "2.1.0", "2.0.2", "2.0.1", "2.0.0",
        "1.1.4", "1.1.2", "1.1.1", "1.0.3",
    ];

    #[yare::parameterized(
        all_same = { vec!["2.5.1", "2.5.1", "2.5.1"], Some("2.5.1") },
        all_caret = { vec!["^2", "^2", "^2"], Some("2.5.1") },
        all_wildcard = { vec!["*", "*", "*"], Some("2.5.1") },
        one_tilde = { vec!["~1.1.1", "^1", "1"], Some("1.1.4") },
        one_wildcard = { vec!["1.*", "^1", "1.1.0"], Some("1.1.4") },
        one_equals = { vec!["=2.2.0", "^2", "2.1.0"], Some("2.2.0") },
        upper_bound = { vec!["^2.0", "<2.5"], Some("2.4.0") },
        all_ranges = { vec!["^2.0", ">=2.1", "<2.3"], Some("2.2.0") },
        lower_bound = { vec!["^1.0", "<1.1"], Some("1.0.3") },
        no_requirements = { vec![], Some("2.5.1") }
    )]
    fn happy(version_reqs: Vec<&str>, expected: Option<&str>) {
        let version_requirements: HashSet<VersionReq> = version_reqs
            .into_iter()
            .map(|req| req.parse().unwrap())
            .collect();
        let versions: Vec<Version> = VERSIONS
            .into_iter()
            .map(|ver| ver.parse().unwrap())
            .collect();
        let expected = expected.map(|ver| ver.parse::<Version>().unwrap());

        let actual = what_version(version_requirements, versions);

        assert_eq!(actual.ok(), expected);
    }

    #[yare::parameterized(
        no_match = { vec!["^3"], None },
        conflicting_ranges = { vec!["^2.0", "<2.0"], None },
        invalid_version = { vec!["=3.0.0", "^2"], None },
    )]
    fn sad(version_reqs: Vec<&str>, expected: Option<&str>) {
        let version_requirements: HashSet<VersionReq> = version_reqs
            .into_iter()
            .map(|req| req.parse().unwrap())
            .collect();
        let versions: Vec<Version> = VERSIONS
            .into_iter()
            .map(|ver| ver.parse().unwrap())
            .collect();
        let expected = expected.map(|ver| ver.parse::<Version>().unwrap());

        let actual = what_version(version_requirements, versions);

        assert_eq!(actual.ok(), expected);
    }
}