binstalk 0.28.70

The binstall toolkit (library interface)
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

use compact_str::format_compact;
use semver::{Prerelease, Version, VersionReq};

/// Extension trait for [`VersionReq`].
pub trait VersionReqExt {
    /// Return `true` if `self.matches(version)` returns `true`
    /// and the `version` is the latest one acceptable by `self`.
    fn is_latest_compatible(&self, version: &Version) -> bool;

    /// Parse from CLI option.
    ///
    /// Notably, a bare version is treated as if preceded by `=`, not by `^` as in Cargo.toml
    /// dependencies.
    fn parse_from_cli(str: &str) -> Result<Self, semver::Error>
    where
        Self: Sized;
}

impl VersionReqExt for VersionReq {
    fn is_latest_compatible(&self, version: &Version) -> bool {
        if !self.matches(version) {
            return false;
        }

        // Test if bumping patch will be accepted
        let bumped_version = Version::new(version.major, version.minor, version.patch + 1);

        if self.matches(&bumped_version) {
            return false;
        }

        // Test if bumping prerelease will be accepted if version has one.
        let pre = &version.pre;
        if !pre.is_empty() {
            // Bump pre by appending random number to the end.
            let bumped_pre = format_compact!("{}.1", pre.as_str());

            let bumped_version = Version {
                major: version.major,
                minor: version.minor,
                patch: version.patch,
                pre: Prerelease::new(&bumped_pre).unwrap(),
                build: Default::default(),
            };

            if self.matches(&bumped_version) {
                return false;
            }
        }

        true
    }

    fn parse_from_cli(version: &str) -> Result<Self, semver::Error> {
        if version
            .chars()
            .next()
            .map(|ch| ch.is_ascii_digit())
            .unwrap_or(false)
        {
            format_compact!("={version}").parse()
        } else {
            version.parse()
        }
    }
}

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

    #[test]
    fn test() {
        // Test star
        assert!(!VersionReq::STAR.is_latest_compatible(&Version::parse("0.0.1").unwrap()));
        assert!(!VersionReq::STAR.is_latest_compatible(&Version::parse("0.1.1").unwrap()));
        assert!(!VersionReq::STAR.is_latest_compatible(&Version::parse("0.1.1-alpha").unwrap()));

        // Test ^x.y.z
        assert!(!VersionReq::parse("^0.1")
            .unwrap()
            .is_latest_compatible(&Version::parse("0.1.99").unwrap()));

        // Test =x.y.z
        assert!(VersionReq::parse("=0.1.0")
            .unwrap()
            .is_latest_compatible(&Version::parse("0.1.0").unwrap()));

        // Test =x.y.z-alpha
        assert!(VersionReq::parse("=0.1.0-alpha")
            .unwrap()
            .is_latest_compatible(&Version::parse("0.1.0-alpha").unwrap()));

        // Test >=x.y.z-alpha
        assert!(!VersionReq::parse(">=0.1.0-alpha")
            .unwrap()
            .is_latest_compatible(&Version::parse("0.1.0-alpha").unwrap()));
    }
}