use crate::core::contract::Scheme;
use crate::core::model::{Availability, Dependency, Verdict, VersionMeta};
#[derive(Debug, Clone)]
pub struct ResolveOptions {
pub include_prerelease: bool,
}
pub fn verdict(
scheme: &dyn Scheme,
dep: &Dependency,
avail: Availability,
opts: &ResolveOptions,
) -> Verdict {
let all_candidates: Vec<&VersionMeta> = avail
.versions
.iter()
.filter(|v| opts.include_prerelease || !scheme.is_prerelease(&v.version))
.collect();
let non_yanked_satisfier_exists = all_candidates
.iter()
.any(|v| !v.yanked && scheme.satisfies(&v.version, &dep.constraint));
let yanked_satisfier_exists = all_candidates
.iter()
.any(|v| v.yanked && scheme.satisfies(&v.version, &dep.constraint));
if !non_yanked_satisfier_exists {
if yanked_satisfier_exists {
return Verdict::Yanked;
} else {
let prerelease_available = if !opts.include_prerelease && !avail.versions.is_empty() {
avail
.versions
.iter()
.any(|v| scheme.satisfies(&v.version, &dep.constraint))
} else {
false
};
return Verdict::Unsatisfiable {
constraint: dep.constraint.clone(),
prerelease_available,
};
}
}
let mut parsed_candidates: Vec<&VersionMeta> = all_candidates
.iter()
.copied()
.filter(|v| !v.yanked)
.collect();
parsed_candidates.sort_by(|a, b| scheme.cmp(&a.version, &b.version));
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, &dep.constraint))
.map(|meta| meta.version.clone());
let latest_pre = avail
.versions
.iter()
.filter(|v| !v.yanked && scheme.is_prerelease(&v.version))
.max_by(|a, b| scheme.cmp(&a.version, &b.version))
.map(|v| v.version.clone())
.filter(|lp| scheme.cmp(lp, &latest_version) == std::cmp::Ordering::Greater);
if scheme.is_upgrade(&dep.constraint, &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::{Constraint, Coordinate, Span, Version};
struct MockSemverScheme;
fn parse_version(v: &str) -> (u32, u32, u32, bool) {
let mut parts = v.split('-');
let main = parts.next().unwrap();
let is_pre = parts.next().is_some();
let mut num_parts = main.split('.');
let major = num_parts.next().unwrap_or("0").parse().unwrap_or(0);
let minor = num_parts.next().unwrap_or("0").parse().unwrap_or(0);
let patch = num_parts.next().unwrap_or("0").parse().unwrap_or(0);
(major, minor, patch, is_pre)
}
impl Scheme for MockSemverScheme {
fn cmp(&self, a: &Version, b: &Version) -> std::cmp::Ordering {
let (a_maj, a_min, a_pat, a_pre) = parse_version(&a.0);
let (b_maj, b_min, b_pat, b_pre) = parse_version(&b.0);
let ord = a_maj
.cmp(&b_maj)
.then(a_min.cmp(&b_min))
.then(a_pat.cmp(&b_pat));
if ord == std::cmp::Ordering::Equal {
match (a_pre, b_pre) {
(true, false) => std::cmp::Ordering::Less,
(false, true) => std::cmp::Ordering::Greater,
_ => std::cmp::Ordering::Equal,
}
} else {
ord
}
}
fn is_prerelease(&self, v: &Version) -> bool {
parse_version(&v.0).3
}
fn satisfies(&self, v: &Version, c: &Constraint) -> bool {
let (v_maj, v_min, v_pat, _) = parse_version(&v.0);
let is_caret =
c.0.starts_with('^') || c.0.chars().next().map_or(false, |ch| ch.is_ascii_digit());
let req = if c.0.starts_with('^') {
&c.0[1..]
} else if c.0.starts_with('=') {
&c.0[1..]
} else {
&c.0
};
let (r_maj, r_min, r_pat, _) = parse_version(req);
if is_caret {
if v_maj != r_maj {
return false;
}
if v_maj == 0 {
if v_min != r_min {
return false;
}
v_pat >= r_pat
} else {
if v_min < r_min {
return false;
}
if v_min == r_min { v_pat >= r_pat } else { true }
}
} else {
v_maj == r_maj && v_min == r_min && v_pat == r_pat
}
}
fn declared_floor(&self, c: &Constraint) -> Option<Version> {
let req = if c.0.starts_with('^') {
&c.0[1..]
} else if c.0.starts_with('=') {
&c.0[1..]
} else {
&c.0
};
Some(Version(req.to_string()))
}
fn rewrite(&self, _c: &Constraint, _target: &Version) -> Option<Constraint> {
None
}
}
#[test]
fn test_resolve_partial_version() {
let dep = Dependency {
coordinate: Coordinate("tokio".into()),
constraint: Constraint("1.36".into()),
span: Some(Span { start: 0, end: 0 }),
source: None,
section: "dependencies".into(),
};
let avail = Availability {
versions: vec![
VersionMeta {
version: Version("1.36.0".into()),
yanked: false,
},
VersionMeta {
version: Version("1.45.0".into()),
yanked: false,
},
],
};
let verdict_val = verdict(
&MockSemverScheme,
&dep,
avail,
&ResolveOptions {
include_prerelease: false,
},
);
assert_eq!(
verdict_val,
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: Constraint("^1.2".into()),
span: Some(Span { start: 0, end: 0 }),
source: None,
section: "dependencies".into(),
};
let avail = Availability {
versions: vec![
VersionMeta {
version: Version("1.2.0".into()),
yanked: false,
},
VersionMeta {
version: Version("1.9.0".into()),
yanked: false,
},
VersionMeta {
version: Version("2.0.0".into()),
yanked: false,
},
],
};
let verdict_val = verdict(
&MockSemverScheme,
&dep,
avail,
&ResolveOptions {
include_prerelease: false,
},
);
assert_eq!(
verdict_val,
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: Constraint("^1.9".into()),
span: Some(Span { start: 0, end: 0 }),
source: None,
section: "dependencies".into(),
};
let avail = Availability {
versions: vec![
VersionMeta {
version: Version("1.9.0".into()),
yanked: false,
},
VersionMeta {
version: Version("2.0.0-rc.1".into()),
yanked: false,
},
],
};
assert_eq!(
verdict(
&MockSemverScheme,
&dep,
avail.clone(),
&ResolveOptions {
include_prerelease: false
}
),
Verdict::Current {
latest: Version("1.9.0".into()),
latest_pre: Some(Version("2.0.0-rc.1".into())),
}
);
assert_eq!(
verdict(
&MockSemverScheme,
&dep,
avail,
&ResolveOptions {
include_prerelease: 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: Constraint("^0.4.13".into()),
span: None,
source: None,
section: "dependencies".into(),
};
let avail = Availability {
versions: vec![
VersionMeta {
version: Version("0.4.13".into()),
yanked: false,
},
VersionMeta {
version: Version("0.4.15".into()),
yanked: false,
},
VersionMeta {
version: Version("0.5.2".into()),
yanked: false,
},
],
};
let verdict_val = verdict(
&MockSemverScheme,
&dep,
avail,
&ResolveOptions {
include_prerelease: false,
},
);
assert_eq!(
verdict_val,
Verdict::Outdated {
compatible: Some(Version("0.4.15".into())),
latest: Version("0.5.2".into()),
latest_pre: None,
}
);
}
#[test]
fn test_resolve_yanked_semantics() {
let dep1 = Dependency {
coordinate: Coordinate("foo".into()),
constraint: Constraint("=1.0.0".into()),
span: None,
source: None,
section: "dependencies".into(),
};
let avail1 = Availability {
versions: vec![
VersionMeta {
version: Version("1.0.0".into()),
yanked: true,
},
VersionMeta {
version: Version("1.2.0".into()),
yanked: false,
},
],
};
assert_eq!(
verdict(
&MockSemverScheme,
&dep1,
avail1,
&ResolveOptions {
include_prerelease: false
}
),
Verdict::Yanked
);
let dep2 = Dependency {
coordinate: Coordinate("foo".into()),
constraint: Constraint("^1.0.0".into()),
span: None,
source: None,
section: "dependencies".into(),
};
let avail2 = Availability {
versions: vec![
VersionMeta {
version: Version("1.0.0".into()),
yanked: true,
},
VersionMeta {
version: Version("1.4.0".into()),
yanked: false,
},
],
};
assert_eq!(
verdict(
&MockSemverScheme,
&dep2,
avail2,
&ResolveOptions {
include_prerelease: false
}
),
Verdict::Outdated {
compatible: Some(Version("1.4.0".into())),
latest: Version("1.4.0".into()),
latest_pre: None,
}
);
let dep3 = Dependency {
coordinate: Coordinate("foo".into()),
constraint: Constraint("=1.0.0".into()),
span: None,
source: None,
section: "dependencies".into(),
};
let avail3 = Availability {
versions: vec![VersionMeta {
version: Version("1.0.0".into()),
yanked: true,
}],
};
assert_eq!(
verdict(
&MockSemverScheme,
&dep3,
avail3,
&ResolveOptions {
include_prerelease: false
}
),
Verdict::Yanked
);
}
}