use super::GoVersion;
use crate::logging;
#[must_use]
pub(crate) fn parse_version_query(raw: &str) -> (Vec<u64>, Option<String>) {
let mut nums = Vec::new();
let mut tag = None;
for part in raw.split('.') {
let digits: String = part.chars().take_while(char::is_ascii_digit).collect();
if !digits.is_empty()
&& let Ok(n) = digits.parse::<u64>()
{
nums.push(n);
}
let idx = part.find(|c: char| c.is_ascii_alphabetic());
if let Some(i) = idx {
tag = Some(part[i..].to_string());
}
}
(nums, tag)
}
#[must_use]
pub(crate) fn version_matches(query_raw: &str, version_raw: &str) -> bool {
let (q_nums, q_tag) = parse_version_query(query_raw);
let (v_nums, v_tag) = parse_version_query(version_raw);
if q_nums.is_empty() || q_nums.len() > v_nums.len() {
return false;
}
if v_nums[..q_nums.len()] != q_nums[..] {
return false;
}
match q_tag {
Some(qt) => v_tag.as_deref() == Some(qt.as_str()),
None => v_tag.is_none(),
}
}
#[must_use]
pub(crate) fn resolve_version<'a>(query: &str, versions: &'a [GoVersion]) -> Option<&'a GoVersion> {
let clean = query.trim().trim_start_matches("go");
if let Some(found) = versions
.iter()
.find(|v| v.raw_version == clean || v.display_name == clean)
{
log_resolution(clean, versions.len(), Some((found, "exact")));
return Some(found);
}
let mut best: Option<&GoVersion> = None;
for v in versions {
if version_matches(clean, &v.raw_version) {
match best {
None => best = Some(v),
Some(b) => {
if is_newer(&v.raw_version, &b.raw_version) {
best = Some(v);
}
}
}
}
}
log_resolution(clean, versions.len(), best.map(|v| (v, "prefix")));
best
}
fn log_resolution(query: &str, candidates: usize, matched: Option<(&GoVersion, &str)>) {
match matched {
Some((version, kind)) => logging::debug(&format!(
"resolve: matched query=\"{query}\" candidates={candidates} version={} kind={kind}",
version.raw_version
)),
None => logging::debug(&format!(
"resolve: no match query=\"{query}\" candidates={candidates} note=no_entry_matched_prefix",
)),
}
}
#[must_use]
pub(crate) fn compare_versions(v1: &str, v2: &str) -> std::cmp::Ordering {
let parse = |v: &str| -> Vec<u32> {
v.split('.')
.filter_map(|p| {
p.chars()
.take_while(char::is_ascii_digit)
.collect::<String>()
.parse()
.ok()
})
.collect()
};
parse(v1).cmp(&parse(v2))
}
fn is_newer(candidate: &str, than: &str) -> bool {
let (a, _) = parse_version_query(candidate);
let (b, _) = parse_version_query(than);
for (x, y) in a.iter().zip(b.iter()) {
if x != y {
return x > y;
}
}
a.len() > b.len()
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
use super::*;
fn gv(raw: &str, stable: bool) -> GoVersion {
GoVersion {
raw_version: raw.to_string(),
display_name: format!("go{raw}"),
filename: format!("go{raw}.tar.gz"),
url: String::new(),
size: 0,
installed: false,
active: false,
path: None,
stable,
}
}
#[test]
fn component_prefixes_respect_boundaries() {
assert!(version_matches("1.2", "1.2.0"));
assert!(version_matches("1.2", "1.2.7"));
assert!(!version_matches("1.2", "1.20.0"));
assert!(!version_matches("1.2", "1.21.6"));
assert!(!version_matches("1.2", "1.24rc1"));
assert!(version_matches("1.20", "1.20.14"));
assert!(!version_matches("1.20", "1.200.0"));
assert!(!version_matches("1.20", "1.2.0"));
}
#[test]
fn prerelease_queries_require_exact_match() {
assert!(version_matches("1.24rc1", "1.24rc1"));
assert!(!version_matches("1.24rc1", "1.24.0"));
assert!(!version_matches("1.24", "1.24rc1"));
assert!(version_matches("1.24", "1.24.0"));
}
#[test]
fn resolver_picks_newest_stable_for_prefix() {
let versions = vec![
gv("1.24.1", true),
gv("1.24.0", true),
gv("1.24rc1", false),
gv("1.23.4", true),
gv("1.22.6", true),
];
let got = resolve_version("1.22", &versions).unwrap();
assert_eq!(got.raw_version, "1.22.6");
let got = resolve_version("1.24", &versions).unwrap();
assert_eq!(got.raw_version, "1.24.1", "stable beats rc, newest wins");
let got = resolve_version("1.24rc1", &versions).unwrap();
assert_eq!(got.raw_version, "1.24rc1");
assert!(
resolve_version("1.2", &versions).is_none(),
"no 1.2 line present"
);
}
#[test]
fn resolver_exact_match_wins() {
let versions = vec![gv("1.22.6", true), gv("1.22.0", true)];
let got = resolve_version("1.22.0", &versions).unwrap();
assert_eq!(got.raw_version, "1.22.0");
}
}