r_description/
version.rs

1//! R Version strings
2use std::cmp::Ordering;
3
4#[derive(Debug, PartialEq, Eq, std::hash::Hash, Clone)]
5/// Represents a version string like "1.2.3" or "1.2.3-alpha"
6pub struct Version {
7    /// Version components like [1, 2, 3]
8    pub components: Vec<u32>,
9    /// Pre-release version like "alpha", "beta", etc.
10    pub pre_release: Option<String>, // Pre-release version like "alpha", "beta", etc.
11}
12
13impl std::fmt::Display for Version {
14    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15        // Format the version string as "major.minor.patch" or "major.minor.patch-pre_release"
16        f.write_str(
17            &self
18                .components
19                .iter()
20                .map(|c| c.to_string())
21                .collect::<Vec<_>>()
22                .join("."),
23        )?;
24        if let Some(pre_release) = &self.pre_release {
25            f.write_str("-")?;
26            f.write_str(pre_release)?;
27        }
28        Ok(())
29    }
30}
31
32impl Version {
33    /// Create a new version
34    pub fn new(major: u32, minor: u32, patch: Option<u32>, pre_release: Option<&str>) -> Self {
35        Self {
36            components: if let Some(patch) = patch {
37                vec![major, minor, patch]
38            } else {
39                vec![major, minor]
40            },
41            pre_release: pre_release.map(|s| s.to_string()),
42        }
43    }
44}
45
46impl std::str::FromStr for Version {
47    type Err = String;
48
49    fn from_str(s: &str) -> Result<Self, Self::Err> {
50        // Split the version string by '.' and '-' to get major, minor, patch, and pre-release
51        let mut parts = s.splitn(2, '-');
52        let version = parts.next().ok_or(format!("Invalid version string: {s}"))?;
53        let pre_release = parts.next().map(|s| s.to_string());
54
55        let components = version
56            .split('.')
57            .map(|part| {
58                part.parse()
59                    .map_err(|_| format!("Invalid version component: {s}"))
60            })
61            .collect::<Result<Vec<_>, _>>()?;
62
63        Ok(Self {
64            components,
65            pre_release,
66        })
67    }
68}
69
70impl Ord for Version {
71    fn cmp(&self, other: &Self) -> Ordering {
72        // Compare components in order, and then compare pre-release tags
73        for (a, b) in self.components.iter().zip(other.components.iter()) {
74            match a.cmp(b) {
75                Ordering::Equal => continue,
76                ordering => return ordering,
77            }
78        }
79        if self.components.len() < other.components.len() {
80            Ordering::Less
81        } else if self.components.len() > other.components.len() {
82            Ordering::Greater
83        } else {
84            self.compare_pre_release(other)
85        }
86    }
87}
88
89impl PartialOrd for Version {
90    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
91        Some(self.cmp(other))
92    }
93}
94
95impl Version {
96    fn compare_pre_release(&self, other: &Self) -> Ordering {
97        match (&self.pre_release, &other.pre_release) {
98            (None, None) => Ordering::Equal,
99            (None, Some(_)) => Ordering::Greater,
100            (Some(_), None) => Ordering::Less,
101            (Some(a), Some(b)) => a.cmp(b),
102        }
103    }
104}
105
106#[cfg(test)]
107mod tests {
108    use super::Version;
109    use std::str::FromStr;
110
111    #[test]
112    fn test_version_from_str() {
113        use std::str::FromStr;
114
115        let version = Version::from_str("1.2.3").unwrap();
116        assert_eq!(version, Version::new(1, 2, Some(3), None));
117
118        let version = Version::from_str("1.2.3-alpha").unwrap();
119        assert_eq!(version, Version::new(1, 2, Some(3), Some("alpha")));
120
121        let version = Version::from_str("1.2.3-beta").unwrap();
122        assert_eq!(version, Version::new(1, 2, Some(3), Some("beta")));
123    }
124
125    #[test]
126    fn test_version_cmp() {
127        use std::cmp::Ordering;
128
129        let v1 = Version::from_str("1.2.3").unwrap();
130        let v2 = Version::from_str("1.2.3").unwrap();
131        assert_eq!(v1.cmp(&v2), Ordering::Equal);
132
133        let v1 = Version::from_str("1.2.3").unwrap();
134        let v2 = Version::from_str("1.2.4").unwrap();
135        assert_eq!(v1.cmp(&v2), Ordering::Less);
136
137        let v1 = Version::from_str("1.2.3").unwrap();
138        let v2 = Version::from_str("1.2.3-alpha").unwrap();
139        assert_eq!(v1.cmp(&v2), Ordering::Greater);
140
141        let v1 = Version::from_str("1.2.3-alpha").unwrap();
142        let v2 = Version::from_str("1.2.3-beta").unwrap();
143        assert_eq!(v1.cmp(&v2), Ordering::Less);
144    }
145
146    #[test]
147    fn test_version_invalid() {
148        assert!(Version::from_str("a").is_err());
149        assert!(Version::from_str("a1-b").is_err());
150    }
151}
r_description/version.rs

r_description/
version.rs
