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)))
}
}