Skip to main content

torii_lib/versioning/
semver.rs

1use anyhow::{Result, anyhow};
2use std::fmt;
3use std::str::FromStr;
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
6pub struct Version {
7    pub major: u32,
8    pub minor: u32,
9    pub patch: u32,
10}
11
12#[derive(Debug, Clone, Copy, PartialEq)]
13pub enum VersionBump {
14    Major,
15    Minor,
16    Patch,
17    None,
18}
19
20impl Version {
21    pub fn new(major: u32, minor: u32, patch: u32) -> Self {
22        Self { major, minor, patch }
23    }
24    
25    pub fn initial() -> Self {
26        Self::new(0, 1, 0)
27    }
28    
29    pub fn bump(&self, bump_type: VersionBump) -> Self {
30        match bump_type {
31            VersionBump::Major => Self::new(self.major + 1, 0, 0),
32            VersionBump::Minor => Self::new(self.major, self.minor + 1, 0),
33            VersionBump::Patch => Self::new(self.major, self.minor, self.patch + 1),
34            VersionBump::None => *self,
35        }
36    }
37}
38
39impl fmt::Display for Version {
40    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
41        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
42    }
43}
44
45impl FromStr for Version {
46    type Err = anyhow::Error;
47    
48    fn from_str(s: &str) -> Result<Self> {
49        // Remove 'v' prefix if present
50        let s = s.trim_start_matches('v');
51        
52        let parts: Vec<&str> = s.split('.').collect();
53        if parts.len() != 3 {
54            return Err(anyhow!("Invalid version format. Expected: major.minor.patch"));
55        }
56        
57        let major = parts[0].parse::<u32>()
58            .map_err(|_| anyhow!("Invalid major version"))?;
59        let minor = parts[1].parse::<u32>()
60            .map_err(|_| anyhow!("Invalid minor version"))?;
61        let patch = parts[2].parse::<u32>()
62            .map_err(|_| anyhow!("Invalid patch version"))?;
63        
64        Ok(Self::new(major, minor, patch))
65    }
66}
67
68#[cfg(test)]
69mod tests {
70    use super::*;
71    
72    #[test]
73    fn test_version_parse() {
74        let v = "1.2.3".parse::<Version>().unwrap();
75        assert_eq!(v.major, 1);
76        assert_eq!(v.minor, 2);
77        assert_eq!(v.patch, 3);
78    }
79    
80    #[test]
81    fn test_version_parse_with_v() {
82        let v = "v2.0.1".parse::<Version>().unwrap();
83        assert_eq!(v.major, 2);
84        assert_eq!(v.minor, 0);
85        assert_eq!(v.patch, 1);
86    }
87    
88    #[test]
89    fn test_version_bump_major() {
90        let v = Version::new(1, 2, 3);
91        let bumped = v.bump(VersionBump::Major);
92        assert_eq!(bumped, Version::new(2, 0, 0));
93    }
94    
95    #[test]
96    fn test_version_bump_minor() {
97        let v = Version::new(1, 2, 3);
98        let bumped = v.bump(VersionBump::Minor);
99        assert_eq!(bumped, Version::new(1, 3, 0));
100    }
101    
102    #[test]
103    fn test_version_bump_patch() {
104        let v = Version::new(1, 2, 3);
105        let bumped = v.bump(VersionBump::Patch);
106        assert_eq!(bumped, Version::new(1, 2, 4));
107    }
108    
109    #[test]
110    fn test_version_display() {
111        let v = Version::new(1, 2, 3);
112        assert_eq!(v.to_string(), "1.2.3");
113    }
114}