ud 0.1.0

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

pub struct NodeScheme;

fn parse_simple_comparator(s: &str) -> Option<(&str, &str)> {
    let s = s.trim();
    let mut op = "";
    let mut rest = s;

    if s.starts_with(">=") {
        op = ">=";
        rest = &s[2..];
    } else if s.starts_with("<=") {
        op = "<=";
        rest = &s[2..];
    } else if s.starts_with('>') {
        op = ">";
        rest = &s[1..];
    } else if s.starts_with('<') {
        op = "<";
        rest = &s[1..];
    } else if s.starts_with('^') {
        op = "^";
        rest = &s[1..];
    } else if s.starts_with('~') {
        op = "~";
        rest = &s[1..];
    } else if s.starts_with('=') {
        op = "=";
        rest = &s[1..];
    }

    let rest = rest.trim_start();
    let rest = if rest.starts_with('v') || rest.starts_with('V') {
        &rest[1..]
    } else {
        rest
    };

    if rest.contains(' ')
        || rest.contains('x')
        || rest.contains('X')
        || rest.contains('*')
        || rest.contains("||")
    {
        return None;
    }

    if deno_semver::npm::parse_npm_version(rest).is_ok() {
        Some((op, rest))
    } else {
        None
    }
}

impl Scheme for NodeScheme {
    fn cmp(&self, a: &Version, b: &Version) -> Ordering {
        let a_parsed = deno_semver::npm::parse_npm_version(&a.0);
        let b_parsed = deno_semver::npm::parse_npm_version(&b.0);
        match (a_parsed, b_parsed) {
            (Ok(a_v), Ok(b_v)) => a_v.cmp(&b_v),
            (Ok(_), Err(_)) => Ordering::Greater,
            (Err(_), Ok(_)) => Ordering::Less,
            (Err(_), Err(_)) => a.0.cmp(&b.0),
        }
    }

    fn is_prerelease(&self, v: &Version) -> bool {
        deno_semver::npm::parse_npm_version(&v.0)
            .map(|v_parsed| !v_parsed.pre.is_empty())
            .unwrap_or(false)
    }

    fn satisfies(&self, v: &Version, c: &Constraint) -> bool {
        let v_parsed = deno_semver::npm::parse_npm_version(&v.0);
        let c_parsed = deno_semver::npm::parse_npm_version_req(&c.0);
        match (v_parsed, c_parsed) {
            (Ok(vp), Ok(cp)) => cp.matches(&vp),
            _ => false,
        }
    }

    fn declared_floor(&self, c: &Constraint) -> Option<Version> {
        let req = deno_semver::npm::parse_npm_version_req(&c.0).ok()?;
        let range_set = req.range()?;

        let mut min_version: Option<deno_semver::Version> = None;

        for range in &range_set.0 {
            if let RangeBound::Version(ref bound) = range.start {
                match min_version {
                    Some(ref current_min) => {
                        if bound.version.cmp(current_min) == Ordering::Less {
                            min_version = Some(bound.version.clone());
                        }
                    }
                    None => {
                        min_version = Some(bound.version.clone());
                    }
                }
            } else {
                let zero_version = deno_semver::Version {
                    major: 0,
                    minor: 0,
                    patch: 0,
                    pre: Default::default(),
                    build: Default::default(),
                };
                min_version = Some(zero_version);
            }
        }

        min_version.map(|v| Version(v.to_string()))
    }

    fn rewrite(&self, c: &Constraint, target: &Version) -> Option<Constraint> {
        let (op, _) = parse_simple_comparator(&c.0)?;
        Some(Constraint(format!("{}{}", op, target.0)))
    }
}