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 = component_cmp(x, y);
if ordering != Ordering::Equal {
return ordering;
}
}
Ordering::Equal
}
fn component_cmp(a: &str, b: &str) -> Ordering {
fn digits(s: &str) -> bool {
s.starts_with(|c: char| c.is_ascii_digit())
}
fn take(s: &str, want_digits: bool) -> (&str, &str) {
let end = s
.find(|c: char| c.is_ascii_digit() != want_digits)
.unwrap_or(s.len());
s.split_at(end)
}
let (mut a, mut b) = (a, b);
loop {
if a.is_empty() || b.is_empty() {
return a.len().cmp(&b.len());
}
let ordering = match (digits(a), digits(b)) {
(true, true) => {
let (x, rest_a) = take(a, true);
let (y, rest_b) = take(b, true);
(a, b) = (rest_a, rest_b);
match (x.parse::<u64>(), y.parse::<u64>()) {
(Ok(x), Ok(y)) => x.cmp(&y),
_ => x.len().cmp(&y.len()).then_with(|| x.cmp(y)),
}
}
(false, false) => {
let (x, rest_a) = take(a, false);
let (y, rest_b) = take(b, false);
(a, b) = (rest_a, rest_b);
x.cmp(y)
}
(true, false) => Ordering::Greater,
(false, true) => Ordering::Less,
};
if ordering != Ordering::Equal {
return ordering;
}
}
}
#[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);
}
#[test]
fn a_leading_zero_does_not_make_a_different_version() {
assert_eq!(version_cmp("1.02", "1.2"), Ordering::Equal);
assert_eq!(version_cmp("2024.01.15", "2024.1.15"), Ordering::Equal);
assert_eq!(version_cmp("1.0002.3", "1.2.3"), Ordering::Equal);
assert_eq!(version_cmp("1.20", "1.2"), Ordering::Greater);
assert_eq!(version_cmp("1.02", "1.3"), Ordering::Less);
}
#[test]
fn a_pre_release_counts_its_number_rather_than_spelling_it() {
assert_eq!(version_cmp("1.0.0-rc10", "1.0.0-rc9"), Ordering::Greater);
assert_eq!(version_cmp("1.0.0-rc2", "1.0.0-rc10"), Ordering::Less);
assert_eq!(version_cmp("1.0.0-beta2", "1.0.0-beta10"), Ordering::Less);
assert_eq!(
version_cmp("2.0.0-beta1", "2.0.0-alpha9"),
Ordering::Greater
);
assert_eq!(version_cmp("1.0.0-rc10", "1.0.0"), Ordering::Less);
}
#[test]
fn a_suffix_still_breaks_a_tie_upward() {
assert_eq!(version_cmp("9.6p1", "9.6"), Ordering::Greater);
assert_eq!(version_cmp("9.6p1", "9.7"), Ordering::Less);
assert_eq!(version_cmp("1.2.3a", "1.2.3"), Ordering::Greater);
assert_eq!(version_cmp("9.6p2", "9.6p10"), Ordering::Less);
}
#[test]
fn the_order_is_antisymmetric() {
let versions = [
"1.02",
"1.2",
"1.2.0",
"9.6",
"9.6p1",
"9.6p10",
"1.0.0-rc9",
"1.0.0-rc10",
"1.0.0",
"1.21.0-1ubuntu2",
"2024.01.15",
"",
"0",
"1.2.3a",
"1.2.3",
"10.0",
"9.9",
];
for a in versions {
for b in versions {
assert_eq!(
version_cmp(a, b),
version_cmp(b, a).reverse(),
"{a:?} against {b:?}"
);
}
}
}
}