cargo-msrv 0.18.0

Find your minimum supported Rust version (MSRV)!
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::manifest::bare_version;
use crate::semver;
use rust_releases::linear::LatestStableReleases;
use rust_releases::Release;

/// Filter releases based on the given configuration.
pub struct ReleasesFilter<'ctx> {
    include_all_patch_releases: bool,
    minimum_version: Option<&'ctx bare_version::BareVersion>,
    maximum_version: Option<&'ctx bare_version::BareVersion>,
}

impl<'ctx> ReleasesFilter<'ctx> {
    /// Initiate a new filter
    pub fn new(
        include_all_patch_releases: bool,
        minimum_version: Option<&'ctx bare_version::BareVersion>,
        maximum_version: Option<&'ctx bare_version::BareVersion>,
    ) -> Self {
        Self {
            include_all_patch_releases,
            minimum_version,
            maximum_version,
        }
    }

    /// Filter the given slice of releases, based on the options set for the filter.
    pub fn filter(&self, releases: &[Release]) -> Vec<Release> {
        let releases = if self.include_all_patch_releases {
            releases.to_vec()
        } else {
            releases.iter().cloned().latest_stable_releases().collect()
        };

        // Pre-filter the [min-version:max-version] range
        releases
            .into_iter()
            .filter(|release| {
                include_version(
                    release.version(),
                    self.minimum_version,
                    self.maximum_version,
                )
            })
            .collect::<Vec<_>>()
    }
}

fn include_version(
    current: &semver::Version,
    min_version: Option<&bare_version::BareVersion>,
    max_version: Option<&bare_version::BareVersion>,
) -> bool {
    match (min_version, &max_version) {
        (Some(min), Some(max)) => min.is_at_least(current) && max.is_at_most(current),
        (Some(min), None) => min.is_at_least(current),
        (None, Some(max)) => max.is_at_most(current),
        (None, None) => true,
    }
}

#[cfg(test)]
mod tests {
    use crate::manifest::bare_version::BareVersion;
    use parameterized::{ide, parameterized};
    use rust_releases::semver::Version;

    use super::*;

    ide!();

    #[test]
    fn max_should_ignore_patch() {
        let current = Version::new(1, 54, 1);
        let max_version = BareVersion::TwoComponents(1, 54);

        assert!(include_version(&current, None, Some(max_version).as_ref()));
    }

    #[test]
    fn max_should_be_strict_about_patch() {
        let current = Version::new(1, 54, 1);
        let max_version = BareVersion::ThreeComponents(1, 54, 0);

        assert!(!include_version(&current, None, Some(max_version).as_ref()));
    }

    #[parameterized(current = {
        50, // -inf <= x <= inf
        50, // 1.50.0 <= x <= inf
        50, // -inf <= x <= 1.50.0
        50, // 1.50.0 <= x <= 1.50.0
        50, // 1.49.0 <= x <= 1.50.0
    }, min = {
        None,
        Some(50),
        None,
        Some(50),
        Some(49),
    }, max = {
        None,
        None,
        Some(50),
        Some(50),
        Some(50),
    })]
    fn test_included_versions(current: u64, min: Option<u64>, max: Option<u64>) {
        let current = Version::new(1, current, 0);
        let min_version = min.map(|m| BareVersion::ThreeComponents(1, m, 0));
        let max_version = max.map(|m| BareVersion::ThreeComponents(1, m, 0));

        assert!(include_version(
            &current,
            min_version.as_ref(),
            max_version.as_ref()
        ));
    }

    #[parameterized(current = {
        50, // -inf <= x <= 1.49.0 : false
        50, // 1.51 <= x <= inf    : false
        50, // 1.51 <= x <= 1.52.0 : false
        50, // 1.48 <= x <= 1.49.0 : false
    }, min = {
        None,
        Some(51),
        Some(51),
        Some(48),
    }, max = {
        Some(49),
        None,
        Some(52),
        Some(49),
    })]
    fn test_excluded_versions(current: u64, min: Option<u64>, max: Option<u64>) {
        let current = Version::new(1, current, 0);
        let min_version = min.map(|m| BareVersion::ThreeComponents(1, m, 0));
        let max_version = max.map(|m| BareVersion::ThreeComponents(1, m, 0));

        assert!(!include_version(
            &current,
            min_version.as_ref(),
            max_version.as_ref()
        ));
    }
}