use std::cmp::Ordering;
pub(crate) fn version_cmp(a: &str, b: &str) -> Ordering {
let (a_release, a_pre) = split_pre_release(a);
let (b_release, b_pre) = split_pre_release(b);
let release = components(a_release, b_release);
if release != Ordering::Equal {
return release;
}
match (a_pre, b_pre) {
(None, None) => Ordering::Equal,
(Some(_), None) => Ordering::Less,
(None, Some(_)) => Ordering::Greater,
(Some(x), Some(y)) => components(x, y),
}
}
fn split_pre_release(version: &str) -> (&str, Option<&str>) {
let mut from = 0;
while let Some(at) = version[from..].find('-') {
let at = from + at;
let rest = &version[at + 1..];
if !rest.starts_with(|c: char| c.is_ascii_digit()) {
return (&version[..at], Some(rest));
}
from = at + 1;
}
(version, None)
}
fn components(a: &str, b: &str) -> Ordering {
let a: Vec<&str> = a.split(['.', '-']).collect();
let b: Vec<&str> = b.split(['.', '-']).collect();
for index in 0..a.len().max(b.len()) {
let x = a.get(index).copied().unwrap_or("0");
let y = b.get(index).copied().unwrap_or("0");
let ordering = leading_number(x)
.cmp(&leading_number(y))
.then_with(|| x.cmp(y));
if ordering != Ordering::Equal {
return ordering;
}
}
Ordering::Equal
}
fn leading_number(component: &str) -> u64 {
let digits = component
.split(|c: char| !c.is_ascii_digit())
.next()
.unwrap_or("");
match digits.parse() {
Ok(value) => value,
Err(_) if digits.is_empty() => 0,
Err(_) => u64::MAX,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_pre_release_precedes_its_version_and_a_revision_follows_it() {
for pre in ["1.0.0-alpha", "1.0.0-rc1", "1.0.0-beta.2", "2.4.1-dev"] {
let release = pre.split('-').next().expect("a release part");
assert_eq!(
version_cmp(pre, release),
Ordering::Less,
"{pre} is a candidate for {release} and comes before it"
);
}
assert_eq!(version_cmp("1.21.0-1ubuntu2", "1.21.0"), Ordering::Greater);
assert_eq!(version_cmp("1.21.0-3", "1.21.0-2"), Ordering::Greater);
}
#[test]
fn pre_releases_of_one_version_are_ordered_against_each_other() {
assert_eq!(version_cmp("1.0.0-alpha", "1.0.0-beta"), Ordering::Less);
assert_eq!(version_cmp("1.0.0-rc1", "1.0.0-rc2"), Ordering::Less);
assert_eq!(version_cmp("1.0.0-alpha", "1.0.0-alpha"), Ordering::Equal);
}
#[test]
fn a_pre_release_still_outranks_an_earlier_version() {
assert_eq!(version_cmp("1.0.0-alpha", "0.9.9"), Ordering::Greater);
assert_eq!(version_cmp("1.0.0-alpha", "1.0.1"), Ordering::Less);
}
#[test]
fn a_pre_release_satisfies_a_bound_its_release_does_not() {
let below = |v: &str| version_cmp(v, "1.0.0") == Ordering::Less;
assert!(below("0.9.9"));
assert!(
below("1.0.0-rc1"),
"the case that was reported not affected"
);
assert!(below("1.0.0-alpha"));
assert!(!below("1.0.0"));
assert!(!below("1.0.1"));
}
#[test]
fn an_absurd_component_sorts_above_a_real_one_rather_than_below() {
assert_eq!(version_cmp("18446744073709551616", "2"), Ordering::Greater);
assert_eq!(version_cmp("2", "18446744073709551616"), Ordering::Less);
}
#[test]
fn version_comparison_is_numeric_per_component_not_lexical() {
assert_eq!(version_cmp("2.14.1", "2.15.0"), Ordering::Less);
assert_eq!(version_cmp("8.10", "8.9"), Ordering::Greater);
assert_eq!(version_cmp("2.14", "2.14.0"), Ordering::Equal);
assert_eq!(version_cmp("1.3.5", "1.3.5a"), Ordering::Less);
assert_eq!(version_cmp("9.6p1", "9.8"), Ordering::Less);
assert_eq!(version_cmp("9.8p1", "9.8"), Ordering::Greater);
}
}