mai_cli/core/

version.rs

use serde::{Deserialize, Serialize};
use std::cmp::Ordering;
use std::fmt;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Version {
    pub major: u32,
    pub minor: u32,
    pub patch: u32,
}

impl Version {
    #[allow(dead_code)]
    pub fn new(major: u32, minor: u32, patch: u32) -> Self {
        Self {
            major,
            minor,
            patch,
        }
    }

    pub fn parse(s: &str) -> Result<Self, String> {
        let parts: Vec<&str> = s.trim().split('.').collect();
        if parts.len() != 3 {
            return Err(format!(
                "Invalid version format: {}. Expected: MAJOR.MINOR.PATCH",
                s
            ));
        }
        let major = parts[0]
            .parse::<u32>()
            .map_err(|e| format!("Invalid major: {}", e))?;
        let minor = parts[1]
            .parse::<u32>()
            .map_err(|e| format!("Invalid minor: {}", e))?;
        let patch = parts[2]
            .parse::<u32>()
            .map_err(|e| format!("Invalid patch: {}", e))?;
        Ok(Self::new(major, minor, patch))
    }

    #[allow(dead_code)]
    pub fn bump_major(&self) -> Self {
        Self::new(self.major + 1, 0, 0)
    }

    #[allow(dead_code)]
    pub fn bump_minor(&self) -> Self {
        Self::new(self.major, self.minor + 1, 0)
    }

    #[allow(dead_code)]
    pub fn bump_patch(&self) -> Self {
        Self::new(self.major, self.minor, self.patch + 1)
    }
}

impl fmt::Display for Version {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
    }
}

impl PartialOrd for Version {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Version {
    fn cmp(&self, other: &Self) -> Ordering {
        self.major
            .cmp(&other.major)
            .then_with(|| self.minor.cmp(&other.minor))
            .then_with(|| self.patch.cmp(&other.patch))
    }
}

/// Version requirement specifier (semver-style ranges)
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum VersionReq {
    /// Exact version: `1.2.3`
    Exact(Version),
    /// Latest version: `latest`
    Latest,
    /// Caret (compatible): `^1.2.3` (>=1.2.3, <2.0.0)
    Caret(Version),
    /// Tilde (patch-level): `~1.2.3` (>=1.2.3, <1.3.0)
    Tilde(Version),
    /// Greater than: `>1.2.3`
    GreaterThan(Version),
    /// Greater or equal: `>=1.2.3`
    GreaterEq(Version),
    /// Less than: `<1.2.3`
    LessThan(Version),
    /// Less or equal: `<=1.2.3`
    LessEq(Version),
    /// Range: `>=1.0.0, <2.0.0`
    Range {
        min: Option<Version>,
        max: Option<Version>,
    },
}

impl VersionReq {
    pub fn parse(s: &str) -> Result<Self, String> {
        let s = s.trim();

        if s.eq_ignore_ascii_case("latest") || s == "*" {
            return Ok(VersionReq::Latest);
        }

        // Handle range with comma: `>=1.0.0, <2.0.0`
        if let Some(pos) = s.find(',') {
            let left = s[..pos].trim();
            let right = s[pos + 1..].trim();
            let min = if left.is_empty() {
                None
            } else {
                match Self::parse_single(left)? {
                    VersionReq::GreaterEq(v) => Some(v),
                    VersionReq::GreaterThan(v) => Some(v),
                    VersionReq::Exact(v) => Some(v),
                    _ => None,
                }
            };
            let max = if right.is_empty() {
                None
            } else {
                match Self::parse_single(right)? {
                    VersionReq::LessThan(v) => Some(v),
                    VersionReq::LessEq(v) => Some(v),
                    VersionReq::Exact(v) => Some(v),
                    _ => None,
                }
            };
            return Ok(VersionReq::Range { min, max });
        }

        Self::parse_single(s)
    }

    fn parse_single(s: &str) -> Result<Self, String> {
        let s = s.trim();

        if let Some(v) = s.strip_prefix("^") {
            Ok(VersionReq::Caret(Version::parse(v)?))
        } else if let Some(v) = s.strip_prefix("~") {
            Ok(VersionReq::Tilde(Version::parse(v)?))
        } else if let Some(v) = s.strip_prefix(">=") {
            Ok(VersionReq::GreaterEq(Version::parse(v)?))
        } else if let Some(v) = s.strip_prefix(">") {
            Ok(VersionReq::GreaterThan(Version::parse(v)?))
        } else if let Some(v) = s.strip_prefix("<=") {
            Ok(VersionReq::LessEq(Version::parse(v)?))
        } else if let Some(v) = s.strip_prefix("<") {
            Ok(VersionReq::LessThan(Version::parse(v)?))
        } else {
            Ok(VersionReq::Exact(Version::parse(s)?))
        }
    }

    /// Check if a version satisfies this requirement
    pub fn matches(&self, version: &Version) -> bool {
        match self {
            VersionReq::Exact(v) => version == v,
            VersionReq::Latest => true,
            VersionReq::Caret(v) => {
                // ^1.2.3 means >=1.2.3, <2.0.0
                version >= v && version.major == v.major
            }
            VersionReq::Tilde(v) => {
                // ~1.2.3 means >=1.2.3, <1.3.0
                version >= v && version.major == v.major && version.minor == v.minor
            }
            VersionReq::GreaterThan(v) => version > v,
            VersionReq::GreaterEq(v) => version >= v,
            VersionReq::LessThan(v) => version < v,
            VersionReq::LessEq(v) => version <= v,
            VersionReq::Range { min, max } => {
                let min_ok = min.as_ref().is_none_or(|m| version >= m);
                let max_ok = max.as_ref().is_none_or(|m| version < m);
                min_ok && max_ok
            }
        }
    }

    /// Select the best matching version from available versions
    pub fn select_best<'a>(&self, available: &'a [Version]) -> Option<&'a Version> {
        let mut candidates: Vec<&Version> = available.iter().filter(|v| self.matches(v)).collect();

        if candidates.is_empty() {
            return None;
        }

        candidates.sort();
        candidates.into_iter().next_back()
    }
}

impl fmt::Display for VersionReq {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            VersionReq::Exact(v) => write!(f, "{}", v),
            VersionReq::Latest => write!(f, "latest"),
            VersionReq::Caret(v) => write!(f, "^{}", v),
            VersionReq::Tilde(v) => write!(f, "~{}", v),
            VersionReq::GreaterThan(v) => write!(f, ">{}", v),
            VersionReq::GreaterEq(v) => write!(f, ">={}", v),
            VersionReq::LessThan(v) => write!(f, "<{}", v),
            VersionReq::LessEq(v) => write!(f, "<={}", v),
            VersionReq::Range { min, max } => match (min, max) {
                (Some(min), Some(max)) => write!(f, ">={}, <{}", min, max),
                (Some(min), None) => write!(f, ">={}", min),
                (None, Some(max)) => write!(f, "<{}", max),
                (None, None) => write!(f, "*"),
            },
        }
    }
}

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

    #[test]
    fn test_version_parse() {
        let v = Version::parse("1.2.3").unwrap();
        assert_eq!(v, Version::new(1, 2, 3));
    }

    #[test]
    fn test_version_cmp() {
        assert!(Version::new(2, 0, 0) > Version::new(1, 9, 9));
        assert!(Version::new(1, 10, 0) > Version::new(1, 9, 9));
    }

    #[test]
    fn test_version_req_parse() {
        assert_eq!(
            VersionReq::parse("1.2.3").unwrap(),
            VersionReq::Exact(Version::new(1, 2, 3))
        );
        assert_eq!(VersionReq::parse("latest").unwrap(), VersionReq::Latest);
        assert_eq!(
            VersionReq::parse("^1.2.3").unwrap(),
            VersionReq::Caret(Version::new(1, 2, 3))
        );
        assert_eq!(
            VersionReq::parse("~1.2.3").unwrap(),
            VersionReq::Tilde(Version::new(1, 2, 3))
        );
        assert_eq!(
            VersionReq::parse(">1.2.3").unwrap(),
            VersionReq::GreaterThan(Version::new(1, 2, 3))
        );
        assert_eq!(
            VersionReq::parse(">=1.2.3").unwrap(),
            VersionReq::GreaterEq(Version::new(1, 2, 3))
        );
        assert_eq!(
            VersionReq::parse("<1.2.3").unwrap(),
            VersionReq::LessThan(Version::new(1, 2, 3))
        );
        assert_eq!(
            VersionReq::parse("<=1.2.3").unwrap(),
            VersionReq::LessEq(Version::new(1, 2, 3))
        );
    }

    #[test]
    fn test_version_req_matches() {
        let v123 = Version::new(1, 2, 3);
        let v124 = Version::new(1, 2, 4);
        let v130 = Version::new(1, 3, 0);
        let v200 = Version::new(2, 0, 0);

        assert!(VersionReq::Exact(v123.clone()).matches(&v123));
        assert!(!VersionReq::Exact(v123.clone()).matches(&v124));

        assert!(VersionReq::Caret(v123.clone()).matches(&v123));
        assert!(VersionReq::Caret(v123.clone()).matches(&v124));
        assert!(!VersionReq::Caret(v123.clone()).matches(&v200));

        assert!(VersionReq::Tilde(v123.clone()).matches(&v123));
        assert!(VersionReq::Tilde(v123.clone()).matches(&v124));
        assert!(!VersionReq::Tilde(v123.clone()).matches(&v130));

        assert!(VersionReq::GreaterThan(v123.clone()).matches(&v124));
        assert!(!VersionReq::GreaterThan(v123.clone()).matches(&v123));

        assert!(VersionReq::GreaterEq(v123.clone()).matches(&v123));
        assert!(VersionReq::GreaterEq(v123.clone()).matches(&v124));

        assert!(VersionReq::LessThan(v123.clone()).matches(&Version::new(1, 2, 2)));
        assert!(!VersionReq::LessThan(v123.clone()).matches(&v123));
    }

    #[test]
    fn test_version_req_select_best() {
        let versions = vec![
            Version::new(1, 0, 0),
            Version::new(1, 1, 0),
            Version::new(1, 2, 0),
            Version::new(1, 2, 3),
            Version::new(2, 0, 0),
        ];

        let req = VersionReq::parse("^1.2.0").unwrap();
        let best = req.select_best(&versions);
        assert_eq!(best, Some(&Version::new(1, 2, 3)));

        let req = VersionReq::parse("latest").unwrap();
        let best = req.select_best(&versions);
        assert_eq!(best, Some(&Version::new(2, 0, 0)));
    }
}