rust-toolchain 1.1.0

Types to model a Rust toolchain
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
127
128
129
130
131
132
133
134
135
136

mod beta;
mod nightly;
mod stable;

use crate::{Date, RustVersion};

pub use beta::Beta;
pub use nightly::Nightly;
pub use stable::Stable;

/// A Rust release [`channel`].
///
/// Does not include the once used `Alpha` release channel, which has not been used post `1.0.0`.
///
/// # Variants
///
/// See also: [`Stable`], [`Beta`] and [`Nightly`].
///
/// # Reading materials
///
/// - [`rustup concepts: channels`]
/// - [`rust book: how rust is made`]
/// - [`rust forge: rust release channel layout`]
/// - [`rust forge: current rust release versions`]
///
///
/// [`channel`]: https://forge.rust-lang.org/#current-release-versions
/// [`rustup concepts: channels`]: https://rust-lang.github.io/rustup/concepts/channels.html
/// [`rust book: how rust is made`]: https://doc.rust-lang.org/book/appendix-07-nightly-rust.html
/// [`rust forge: rust release channel layout`]: https://forge.rust-lang.org/infra/channel-layout.html#the-rust-release-channel-layout
/// [`rust forge: current rust release versions`]: https://forge.rust-lang.org/#current-release-versions
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Channel {
    /// The stable release channel
    Stable(Stable),
    /// The beta release channel
    Beta(Beta),
    /// The nightly release channel
    Nightly(Nightly),
}

impl Channel {
    /// Create a new [`Stable`] channel instance.
    pub fn stable(version: RustVersion) -> Self {
        Channel::Stable(Stable { version })
    }

    /// Create a new [`Beta`] channel instance.
    pub fn beta(version: RustVersion) -> Self {
        Channel::Beta(Beta {
            version,
            prerelease: None,
        })
    }

    /// Create a new [`Nightly`] channel instance.
    pub fn nightly(date: Date) -> Self {
        Channel::Nightly(Nightly { date })
    }

    /// Whether the given [`Channel`] is of the [`Stable`] variant.
    pub fn is_stable(&self) -> bool {
        matches!(self, Self::Stable(_))
    }

    /// Whether the given [`Channel`] is of the [`Beta`] variant.
    pub fn is_beta(&self) -> bool {
        matches!(self, Self::Beta(_))
    }

    /// Whether the given [`Channel`] is of the [`Nightly`] variant.
    pub fn is_nightly(&self) -> bool {
        matches!(self, Self::Nightly(_))
    }

    /// Returns the release version, or None, if it's a nightly release.
    pub fn version(&self) -> Option<RustVersion> {
        match self {
            Channel::Stable(v) => Some(v.version),
            Channel::Beta(v) => Some(v.version),
            Channel::Nightly(_) => None,
        }
    }

    /// Returns the release date, or
    pub fn date(&self) -> Option<Date> {
        match self {
            Channel::Stable(_) => None,
            Channel::Beta(_) => None,
            Channel::Nightly(v) => Some(v.date.clone()),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{Date, RustVersion};
    use yare::parameterized;

    #[test]
    fn create_channel_stable() {
        let stable = Channel::stable(RustVersion::new(1, 2, 3));

        assert!(stable.is_stable());
        assert!(!stable.is_beta());
        assert!(!stable.is_nightly());
    }

    #[test]
    fn create_channel_beta() {
        let stable = Channel::beta(RustVersion::new(1, 2, 3));

        assert!(!stable.is_stable());
        assert!(stable.is_beta());
        assert!(!stable.is_nightly());
    }

    #[test]
    fn create_channel_nightly() {
        let stable = Channel::nightly(Date::new(1, 1, 1));

        assert!(!stable.is_stable());
        assert!(!stable.is_beta());
        assert!(stable.is_nightly());
    }

    #[parameterized(
        stable = { Channel::stable("1.2.3".parse().unwrap()), Some(RustVersion::new(1,2,3)) },
        beta = { Channel::beta("1.2.3".parse().unwrap()), Some(RustVersion::new(1,2,3)) },
        nightly = { Channel::nightly(Date::new(2024, 1, 1)), None }
    )]
    fn version(c: Channel, expected: Option<RustVersion>) {
        assert_eq!(c.version(), expected)
    }
}