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

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

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

impl<C> NightlyReleases<C> {
    /// Add a stable release
    pub fn add(&mut self, release: RustRelease<Nightly, 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<Nightly, 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: NightlyReleases<C>, merge_fn: F) -> NightlyReleases<C>
    where
        F: Fn(RustRelease<Nightly, C>, RustRelease<Nightly, C>) -> RustRelease<Nightly, C>,
    {
        NightlyReleases(self.0.merge_with(right.0, merge_fn))
    }
}

impl NightlyReleases<()> {
    /// 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: NightlyReleases<()>) -> NightlyReleases<()> {
        self.merge_with(right, crate::merge::merge_default)
    }
}

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

    fn make_release(year: u16, month: u8, day: u8) -> RustRelease<Nightly> {
        RustRelease::new(
            Nightly {
                date: Date::new(year, month, day),
            },
            None,
            [],
        )
    }

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

        let mut right = NightlyReleases::default();
        right.add(make_release(2024, 1, 2));
        right.add(make_release(2024, 1, 3));

        let merged = left.merge(right);

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

        let versions: Vec<_> = merged.iter().map(|r| &r.version).collect();
        assert!(versions.contains(&&Nightly {
            date: Date::new(2024, 1, 1)
        }));
        assert!(versions.contains(&&Nightly {
            date: Date::new(2024, 1, 2)
        }));
        assert!(versions.contains(&&Nightly {
            date: Date::new(2024, 1, 3)
        }));
    }
}