rust-releases-core 0.33.0

Base traits and definitions for rust-releases
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

use crate::releases::impls;
use crate::Beta;
use rust_release::RustRelease;

#[derive(Debug, Default)]
pub struct BetaReleases<C = ()>(impls::ReleasesImpl<Beta, C>);

impl<C> BetaReleases<C> {
    /// Add a stable release
    pub fn add(&mut self, release: RustRelease<Beta, C>) {
        self.0.add(release);
    }

    /// Get the number of releases
    pub fn len(&self) -> usize {
        self.0.len()
    }

    /// Returns true if there are no releases, and false otherwise.
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Iterate over the releases
    pub fn iter(&self) -> impl Iterator<Item = &RustRelease<Beta, C>> {
        self.0.iter()
    }

    /// Merge two collections, applying `merge_fn` to releases that exist in both.
    ///
    /// Releases that exist in only one collection are included unchanged.
    pub fn merge_with<F>(self, right: BetaReleases<C>, merge_fn: F) -> BetaReleases<C>
    where
        F: Fn(RustRelease<Beta, C>, RustRelease<Beta, C>) -> RustRelease<Beta, C>,
    {
        BetaReleases(self.0.merge_with(right.0, merge_fn))
    }
}

impl BetaReleases<()> {
    /// Merge two collections using default strategies (prefer left date, union toolchains).
    ///
    /// Releases that exist in only one collection are included unchanged.
    pub fn merge(self, right: BetaReleases<()>) -> BetaReleases<()> {
        self.merge_with(right, crate::merge::merge_default)
    }
}

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

    fn make_release(major: u64, minor: u64, patch: u64) -> RustRelease<Beta> {
        RustRelease::new(
            Beta {
                version: RustVersion::new(major, minor, patch),
                prerelease: None,
            },
            None,
            [],
        )
    }

    #[test]
    fn merge_overlapping_sets() {
        let mut left = BetaReleases::default();
        left.add(make_release(1, 0, 0));
        left.add(make_release(2, 0, 0));

        let mut right = BetaReleases::default();
        right.add(make_release(2, 0, 0));
        right.add(make_release(3, 0, 0));

        let merged = left.merge(right);

        assert_eq!(merged.len(), 3);

        let versions: Vec<_> = merged.iter().map(|r| &r.version).collect();
        assert!(versions.contains(&&Beta {
            version: RustVersion::new(1, 0, 0),
            prerelease: None
        }));
        assert!(versions.contains(&&Beta {
            version: RustVersion::new(2, 0, 0),
            prerelease: None
        }));
        assert!(versions.contains(&&Beta {
            version: RustVersion::new(3, 0, 0),
            prerelease: None
        }));
    }
}