use crate::core::contract::Scheme;
use crate::core::model::{Availability, Dependency, Verdict, Version};
use semver::{Version as SemVersion, VersionReq};
pub struct SemverScheme;
impl Scheme for SemverScheme {
fn is_newer(&self, a: &Version, b: &Version) -> bool {
let a_v = SemVersion::parse(&a.0);
let b_v = SemVersion::parse(&b.0);
match (a_v, b_v) {
(Ok(a), Ok(b)) => b > a,
_ => false,
}
}
fn satisfies(&self, version: &Version, constraint: &crate::core::model::Constraint) -> bool {
let v = SemVersion::parse(&version.0);
let req = VersionReq::parse(&constraint.0);
match (v, req) {
(Ok(v), Ok(req)) => req.matches(&v),
_ => false,
}
}
}
fn declared_version(constraint: &str) -> Option<SemVersion> {
let req = VersionReq::parse(constraint).ok()?;
let comp = req
.comparators
.iter()
.find(|c| !matches!(c.op, semver::Op::Less | semver::Op::LessEq));
let version = match comp {
Some(c) => SemVersion {
major: c.major,
minor: c.minor.unwrap_or(0),
patch: c.patch.unwrap_or(0),
pre: c.pre.clone(),
build: semver::BuildMetadata::EMPTY,
},
None => SemVersion {
major: 0,
minor: 0,
patch: 0,
pre: semver::Prerelease::EMPTY,
build: semver::BuildMetadata::EMPTY,
},
};
Some(version)
}
pub fn is_actual_upgrade(constraint: &str, target: &str) -> bool {
let parsed_target = SemVersion::parse(target).ok();
let base_version = declared_version(constraint);
match (parsed_target, base_version) {
(Some(t), Some(b)) => t > b,
_ => target != constraint,
}
}
pub fn resolve(
dependency: &Dependency,
availability: &Availability,
scheme: &dyn Scheme,
include_prerelease: bool,
) -> Verdict {
let mut parsed_candidates: Vec<(&crate::core::model::VersionMetadata, Option<SemVersion>)> =
availability
.versions
.iter()
.filter(|v| !v.yanked)
.filter(|v| include_prerelease || !v.prerelease)
.map(|v| {
let parsed = SemVersion::parse(&v.version.0).ok();
(v, parsed)
})
.collect();
if parsed_candidates.is_empty() {
return Verdict::Unsatisfiable {
constraint: dependency.constraint.clone(),
};
}
parsed_candidates.sort_by(|a, b| match (&a.1, &b.1) {
(Some(av), Some(bv)) => av.cmp(bv),
(Some(_), None) => std::cmp::Ordering::Greater,
(None, Some(_)) => std::cmp::Ordering::Less,
(None, None) => a.0.version.0.cmp(&b.0.version.0),
});
let (latest_meta, _) = parsed_candidates.last().unwrap();
let latest_version = latest_meta.version.clone();
let latest_compatible = parsed_candidates
.iter()
.rev()
.find(|(meta, _)| scheme.satisfies(&meta.version, &dependency.constraint))
.map(|(meta, _)| meta.version.clone());
let latest_pre = availability
.versions
.iter()
.filter(|v| !v.yanked && v.prerelease)
.filter_map(|v| {
let parsed = SemVersion::parse(&v.version.0).ok()?;
Some((v, parsed))
})
.max_by(|a, b| a.1.cmp(&b.1))
.map(|(v, _)| v.version.clone())
.filter(|lp| {
let lp_v = SemVersion::parse(&lp.0).ok();
let target_v = SemVersion::parse(&latest_version.0).ok();
match (lp_v, target_v) {
(Some(lp_v), Some(target_v)) => lp_v > target_v,
_ => false,
}
});
let declared_semver = declared_version(&dependency.constraint.0);
let declared_version = match &declared_semver {
Some(sv) => Version(sv.to_string()),
None => Version(dependency.constraint.0.clone()),
};
if scheme.is_newer(&declared_version, &latest_version) {
Verdict::Outdated {
compatible: latest_compatible,
latest: latest_version,
latest_pre,
}
} else {
Verdict::Current {
latest: latest_version,
latest_pre,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::model::{Coordinate, Span, VersionMetadata};
#[test]
fn test_declared_version() {
assert_eq!(
declared_version("1.36").unwrap(),
SemVersion::parse("1.36.0").unwrap()
);
assert_eq!(
declared_version("^1.2").unwrap(),
SemVersion::parse("1.2.0").unwrap()
);
assert_eq!(
declared_version(">=1, <2").unwrap(),
SemVersion::parse("1.0.0").unwrap()
);
assert_eq!(
declared_version("=2.3.4").unwrap(),
SemVersion::parse("2.3.4").unwrap()
);
assert_eq!(
declared_version("<2").unwrap(),
SemVersion::parse("0.0.0").unwrap()
);
}
#[test]
fn test_resolve_partial_version() {
let dep = Dependency {
coordinate: Coordinate("tokio".into()),
constraint: crate::core::model::Constraint("1.36".into()),
span: Some(Span { start: 0, end: 0 }),
source_hint: None,
section: None,
};
let avail = Availability {
versions: vec![
VersionMetadata {
version: Version("1.36.0".into()),
yanked: false,
prerelease: false,
},
VersionMetadata {
version: Version("1.45.0".into()),
yanked: false,
prerelease: false,
},
],
};
let verdict = resolve(&dep, &avail, &SemverScheme, false);
assert_eq!(
verdict,
Verdict::Outdated {
compatible: Some(Version("1.45.0".into())),
latest: Version("1.45.0".into()),
latest_pre: None,
}
);
}
#[test]
fn test_resolve_compatible_and_breaking() {
let dep = Dependency {
coordinate: Coordinate("serde".into()),
constraint: crate::core::model::Constraint("^1.2".into()),
span: Some(Span { start: 0, end: 0 }),
source_hint: None,
section: None,
};
let avail = Availability {
versions: vec![
VersionMetadata {
version: Version("1.2.0".into()),
yanked: false,
prerelease: false,
},
VersionMetadata {
version: Version("1.9.0".into()),
yanked: false,
prerelease: false,
},
VersionMetadata {
version: Version("2.0.0".into()),
yanked: false,
prerelease: false,
},
],
};
let verdict = resolve(&dep, &avail, &SemverScheme, false);
assert_eq!(
verdict,
Verdict::Outdated {
compatible: Some(Version("1.9.0".into())),
latest: Version("2.0.0".into()),
latest_pre: None,
}
);
}
#[test]
fn test_resolve_prerelease() {
let dep = Dependency {
coordinate: Coordinate("foo".into()),
constraint: crate::core::model::Constraint("^1.9".into()),
span: Some(Span { start: 0, end: 0 }),
source_hint: None,
section: None,
};
let avail = Availability {
versions: vec![
VersionMetadata {
version: Version("1.9.0".into()),
yanked: false,
prerelease: false,
},
VersionMetadata {
version: Version("2.0.0-rc.1".into()),
yanked: false,
prerelease: true,
},
],
};
assert_eq!(
resolve(&dep, &avail, &SemverScheme, false),
Verdict::Current {
latest: Version("1.9.0".into()),
latest_pre: Some(Version("2.0.0-rc.1".into())),
}
);
assert_eq!(
resolve(&dep, &avail, &SemverScheme, true),
Verdict::Outdated {
compatible: Some(Version("1.9.0".into())),
latest: Version("2.0.0-rc.1".into()),
latest_pre: None,
}
);
}
#[test]
fn test_resolve_0x_breaking() {
let dep = Dependency {
coordinate: Coordinate("tower".into()),
constraint: crate::core::model::Constraint("^0.4.13".into()),
span: None,
source_hint: None,
section: None,
};
let avail = Availability {
versions: vec![
VersionMetadata {
version: Version("0.4.13".into()),
yanked: false,
prerelease: false,
},
VersionMetadata {
version: Version("0.4.15".into()),
yanked: false,
prerelease: false,
},
VersionMetadata {
version: Version("0.5.2".into()),
yanked: false,
prerelease: false,
},
],
};
let verdict = resolve(&dep, &avail, &SemverScheme, false);
assert_eq!(
verdict,
Verdict::Outdated {
compatible: Some(Version("0.4.15".into())),
latest: Version("0.5.2".into()),
latest_pre: None,
}
);
}
}