robinpath_modules/modules/

semver_mod.rs

use robinpath::{RobinPath, Value};

pub fn register(rp: &mut RobinPath) {
    rp.register_builtin("semver.parse", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match parse_semver(&s) {
            Some(sv) => {
                let mut obj = indexmap::IndexMap::new();
                obj.insert("major".to_string(), Value::Number(sv.major as f64));
                obj.insert("minor".to_string(), Value::Number(sv.minor as f64));
                obj.insert("patch".to_string(), Value::Number(sv.patch as f64));
                obj.insert("prerelease".to_string(), match &sv.prerelease {
                    Some(p) => Value::String(p.clone()),
                    None => Value::Null,
                });
                obj.insert("build".to_string(), match &sv.build {
                    Some(b) => Value::String(b.clone()),
                    None => Value::Null,
                });
                Ok(Value::Object(obj))
            }
            None => Ok(Value::Null),
        }
    });

    rp.register_builtin("semver.isValid", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Bool(parse_semver(&s).is_some()))
    });

    rp.register_builtin("semver.compare", |args, _| {
        let v1 = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let v2 = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match (parse_semver(&v1), parse_semver(&v2)) {
            (Some(a), Some(b)) => Ok(Value::Number(compare_semver(&a, &b) as f64)),
            _ => Ok(Value::Null),
        }
    });

    rp.register_builtin("semver.gt", |args, _| {
        let v1 = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let v2 = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match (parse_semver(&v1), parse_semver(&v2)) {
            (Some(a), Some(b)) => Ok(Value::Bool(compare_semver(&a, &b) > 0)),
            _ => Ok(Value::Bool(false)),
        }
    });

    rp.register_builtin("semver.lt", |args, _| {
        let v1 = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let v2 = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match (parse_semver(&v1), parse_semver(&v2)) {
            (Some(a), Some(b)) => Ok(Value::Bool(compare_semver(&a, &b) < 0)),
            _ => Ok(Value::Bool(false)),
        }
    });

    rp.register_builtin("semver.eq", |args, _| {
        let v1 = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let v2 = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match (parse_semver(&v1), parse_semver(&v2)) {
            (Some(a), Some(b)) => Ok(Value::Bool(compare_semver(&a, &b) == 0)),
            _ => Ok(Value::Bool(false)),
        }
    });

    rp.register_builtin("semver.gte", |args, _| {
        let v1 = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let v2 = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match (parse_semver(&v1), parse_semver(&v2)) {
            (Some(a), Some(b)) => Ok(Value::Bool(compare_semver(&a, &b) >= 0)),
            _ => Ok(Value::Bool(false)),
        }
    });

    rp.register_builtin("semver.lte", |args, _| {
        let v1 = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let v2 = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match (parse_semver(&v1), parse_semver(&v2)) {
            (Some(a), Some(b)) => Ok(Value::Bool(compare_semver(&a, &b) <= 0)),
            _ => Ok(Value::Bool(false)),
        }
    });

    rp.register_builtin("semver.inc", |args, _| {
        let v = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let release = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| "patch".to_string());
        match parse_semver(&v) {
            Some(mut sv) => {
                match release.as_str() {
                    "major" => { sv.major += 1; sv.minor = 0; sv.patch = 0; sv.prerelease = None; }
                    "minor" => { sv.minor += 1; sv.patch = 0; sv.prerelease = None; }
                    "patch" => { sv.patch += 1; sv.prerelease = None; }
                    "prerelease" => {
                        match &sv.prerelease {
                            Some(p) => {
                                // Try to increment number at end
                                if let Some(n) = p.rsplit('.').next().and_then(|s| s.parse::<u64>().ok()) {
                                    let prefix = &p[..p.rfind('.').map_or(0, |i| i + 1)];
                                    sv.prerelease = Some(format!("{}{}", prefix, n + 1));
                                } else {
                                    sv.prerelease = Some(format!("{}.0", p));
                                }
                            }
                            None => {
                                sv.patch += 1;
                                sv.prerelease = Some("0".to_string());
                            }
                        }
                    }
                    _ => sv.patch += 1,
                }
                sv.build = None;
                Ok(Value::String(sv.to_string()))
            }
            None => Ok(Value::Null),
        }
    });

    rp.register_builtin("semver.major", |args, _| {
        let v = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match parse_semver(&v) {
            Some(sv) => Ok(Value::Number(sv.major as f64)),
            None => Ok(Value::Null),
        }
    });

    rp.register_builtin("semver.minor", |args, _| {
        let v = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match parse_semver(&v) {
            Some(sv) => Ok(Value::Number(sv.minor as f64)),
            None => Ok(Value::Null),
        }
    });

    rp.register_builtin("semver.patch", |args, _| {
        let v = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match parse_semver(&v) {
            Some(sv) => Ok(Value::Number(sv.patch as f64)),
            None => Ok(Value::Null),
        }
    });

    rp.register_builtin("semver.coerce", |args, _| {
        let v = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let cleaned = v.trim_start_matches('v').trim_start_matches('V');
        let parts: Vec<&str> = cleaned.split('.').collect();
        let major = parts.first().and_then(|s| s.parse::<u64>().ok()).unwrap_or(0);
        let minor = parts.get(1).and_then(|s| s.parse::<u64>().ok()).unwrap_or(0);
        let patch = parts.get(2).and_then(|s| s.split('-').next().and_then(|s| s.parse::<u64>().ok())).unwrap_or(0);
        Ok(Value::String(format!("{}.{}.{}", major, minor, patch)))
    });

    rp.register_builtin("semver.diff", |args, _| {
        let v1 = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let v2 = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match (parse_semver(&v1), parse_semver(&v2)) {
            (Some(a), Some(b)) => {
                if a.major != b.major {
                    Ok(Value::String("major".to_string()))
                } else if a.minor != b.minor {
                    Ok(Value::String("minor".to_string()))
                } else if a.patch != b.patch {
                    Ok(Value::String("patch".to_string()))
                } else if a.prerelease != b.prerelease {
                    Ok(Value::String("prerelease".to_string()))
                } else {
                    Ok(Value::Null)
                }
            }
            _ => Ok(Value::Null),
        }
    });

    rp.register_builtin("semver.satisfies", |args, _| {
        let version = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let range = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let sv = match parse_semver(&version) {
            Some(v) => v,
            None => return Ok(Value::Bool(false)),
        };
        Ok(Value::Bool(satisfies_range(&sv, &range)))
    });
}

#[derive(Clone)]
struct SemVer {
    major: u64,
    minor: u64,
    patch: u64,
    prerelease: Option<String>,
    build: Option<String>,
}

impl std::fmt::Display for SemVer {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)?;
        if let Some(ref pre) = self.prerelease {
            write!(f, "-{}", pre)?;
        }
        if let Some(ref build) = self.build {
            write!(f, "+{}", build)?;
        }
        Ok(())
    }
}

fn parse_semver(s: &str) -> Option<SemVer> {
    let s = s.trim().trim_start_matches('v').trim_start_matches('V');
    if s.is_empty() {
        return None;
    }

    let (version_part, build) = if let Some(pos) = s.find('+') {
        (&s[..pos], Some(s[pos + 1..].to_string()))
    } else {
        (s, None)
    };

    let (version_part, prerelease) = if let Some(pos) = version_part.find('-') {
        (&version_part[..pos], Some(version_part[pos + 1..].to_string()))
    } else {
        (version_part, None)
    };

    let parts: Vec<&str> = version_part.split('.').collect();
    let major = parts.first()?.parse().ok()?;
    let minor = parts.get(1).and_then(|s| s.parse().ok()).unwrap_or(0);
    let patch = parts.get(2).and_then(|s| s.parse().ok()).unwrap_or(0);

    Some(SemVer { major, minor, patch, prerelease, build })
}

fn compare_semver(a: &SemVer, b: &SemVer) -> i32 {
    if a.major != b.major {
        return if a.major > b.major { 1 } else { -1 };
    }
    if a.minor != b.minor {
        return if a.minor > b.minor { 1 } else { -1 };
    }
    if a.patch != b.patch {
        return if a.patch > b.patch { 1 } else { -1 };
    }
    // Prerelease: version without prerelease > version with prerelease
    match (&a.prerelease, &b.prerelease) {
        (None, None) => 0,
        (None, Some(_)) => 1,
        (Some(_), None) => -1,
        (Some(pa), Some(pb)) => pa.cmp(pb) as i32,
    }
}

fn satisfies_range(sv: &SemVer, range: &str) -> bool {
    // Handle || (OR)
    for part in range.split("||") {
        let part = part.trim();
        if satisfies_single(sv, part) {
            return true;
        }
    }
    false
}

fn satisfies_single(sv: &SemVer, range: &str) -> bool {
    let range = range.trim();
    if range.is_empty() || range == "*" {
        return true;
    }

    // Handle space-separated AND conditions
    let conditions: Vec<&str> = range.split_whitespace().collect();
    if conditions.len() > 1 {
        // Check if it's ">=X <Y" style
        let mut i = 0;
        while i < conditions.len() {
            let cond = conditions[i];
            if !satisfies_comparator(sv, cond) {
                return false;
            }
            i += 1;
        }
        return true;
    }

    // ^ range (compatible)
    if let Some(r) = range.strip_prefix('^') {
        if let Some(target) = parse_semver(r) {
            if sv.major != target.major {
                return false;
            }
            return compare_semver(sv, &target) >= 0;
        }
        return false;
    }

    // ~ range (approximately)
    if let Some(r) = range.strip_prefix('~') {
        if let Some(target) = parse_semver(r) {
            if sv.major != target.major || sv.minor != target.minor {
                return false;
            }
            return sv.patch >= target.patch;
        }
        return false;
    }

    satisfies_comparator(sv, range)
}

fn satisfies_comparator(sv: &SemVer, cond: &str) -> bool {
    if let Some(r) = cond.strip_prefix(">=") {
        parse_semver(r).is_some_and(|t| compare_semver(sv, &t) >= 0)
    } else if let Some(r) = cond.strip_prefix("<=") {
        parse_semver(r).is_some_and(|t| compare_semver(sv, &t) <= 0)
    } else if let Some(r) = cond.strip_prefix('>') {
        parse_semver(r).is_some_and(|t| compare_semver(sv, &t) > 0)
    } else if let Some(r) = cond.strip_prefix('<') {
        parse_semver(r).is_some_and(|t| compare_semver(sv, &t) < 0)
    } else if let Some(r) = cond.strip_prefix('=') {
        parse_semver(r).is_some_and(|t| compare_semver(sv, &t) == 0)
    } else {
        parse_semver(cond).is_some_and(|t| compare_semver(sv, &t) == 0)
    }
}