ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
use crate::core::contract::Scheme;
use crate::core::model::{Constraint, Version};
use semver::{Version as SemVersion, VersionReq};
use std::cmp::Ordering;

pub struct CargoScheme;

impl Scheme for CargoScheme {
    fn cmp(&self, a: &Version, b: &Version) -> Ordering {
        let a_v = SemVersion::parse(&a.0);
        let b_v = SemVersion::parse(&b.0);

        match (a_v, b_v) {
            (Ok(a_p), Ok(b_p)) => a_p.cmp(&b_p),
            (Ok(_), Err(_)) => Ordering::Greater,
            (Err(_), Ok(_)) => Ordering::Less,
            (Err(_), Err(_)) => a.0.cmp(&b.0),
        }
    }

    fn is_prerelease(&self, v: &Version) -> bool {
        SemVersion::parse(&v.0)
            .map(|parsed| !parsed.pre.is_empty())
            .unwrap_or(false)
    }

    fn satisfies(&self, v: &Version, c: &Constraint) -> bool {
        let parsed_v = SemVersion::parse(&v.0);
        let parsed_req = VersionReq::parse(&c.0);

        match (parsed_v, parsed_req) {
            (Ok(pv), Ok(preq)) => preq.matches(&pv),
            _ => false,
        }
    }

    fn declared_floor(&self, c: &Constraint) -> Option<Version> {
        let req = VersionReq::parse(&c.0).ok()?;
        let comp = req
            .comparators
            .iter()
            .find(|comp| !matches!(comp.op, semver::Op::Less | semver::Op::LessEq));

        let version = match comp {
            Some(comp) => SemVersion {
                major: comp.major,
                minor: comp.minor.unwrap_or(0),
                patch: comp.patch.unwrap_or(0),
                pre: comp.pre.clone(),
                build: semver::BuildMetadata::EMPTY,
            },
            None => SemVersion {
                major: 0,
                minor: 0,
                patch: 0,
                pre: semver::Prerelease::EMPTY,
                build: semver::BuildMetadata::EMPTY,
            },
        };
        Some(Version(version.to_string()))
    }

    fn rewrite(&self, _c: &Constraint, target: &Version) -> Option<Constraint> {
        // Cargo bare constraint means caret range, so rewriting to the bare target is correct.
        Some(Constraint(target.0.clone()))
    }
}