use serde::{Deserialize, Serialize};
use std::cmp::Ordering;
pub fn parse_version(text: &str) -> Vec<i64> {
text.trim()
.split('.')
.map(|part| {
let part = part.trim_start();
let len = part
.char_indices()
.take_while(|(i, c)| c.is_ascii_digit() || (*i == 0 && (*c == '-' || *c == '+')))
.map(|(i, c)| i + c.len_utf8())
.last()
.unwrap_or(0);
part[..len].parse().unwrap_or(0)
})
.collect()
}
pub fn compare_versions(a: &str, b: &str) -> Ordering {
let a = parse_version(a);
let b = parse_version(b);
(0..a.len().max(b.len()))
.map(|i| a.get(i).unwrap_or(&0).cmp(b.get(i).unwrap_or(&0)))
.find(|o| *o != Ordering::Equal)
.unwrap_or(Ordering::Equal)
}
pub fn game_line(version: &str) -> String {
let parts = parse_version(version);
format!(
"{}.{}",
parts.first().unwrap_or(&0),
parts.get(1).unwrap_or(&0)
)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum DependencyKind {
Required,
Optional,
HiddenOptional,
Incompatible,
NoLoadOrder,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Comparator {
#[serde(rename = "<")]
Less,
#[serde(rename = "<=")]
LessEqual,
#[serde(rename = "=")]
Equal,
#[serde(rename = ">=")]
GreaterEqual,
#[serde(rename = ">")]
Greater,
}
impl std::fmt::Display for Comparator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Self::Less => "<",
Self::LessEqual => "<=",
Self::Equal => "=",
Self::GreaterEqual => ">=",
Self::Greater => ">",
})
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Dependency {
pub kind: DependencyKind,
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub comparator: Option<Comparator>,
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
pub fn parse_dependency(text: &str) -> Option<Dependency> {
let mut text = text.trim();
let mut kind = DependencyKind::Required;
for (prefix, k) in [
("(?)", DependencyKind::HiddenOptional),
("?", DependencyKind::Optional),
("!", DependencyKind::Incompatible),
("~", DependencyKind::NoLoadOrder),
] {
if let Some(rest) = text.strip_prefix(prefix) {
kind = k;
text = rest.trim_start();
break;
}
}
let at = text.find(['<', '>', '=']).unwrap_or(text.len());
let name = text[..at].trim();
if name.is_empty() || name.contains(['!', '?', '~', '(', ')']) {
return None;
}
let mut dep = Dependency {
kind,
name: name.into(),
comparator: None,
version: None,
};
if at < text.len() {
let rest = &text[at..];
let (symbol, comparator) = [
("<=", Comparator::LessEqual),
(">=", Comparator::GreaterEqual),
("<", Comparator::Less),
(">", Comparator::Greater),
("=", Comparator::Equal),
]
.into_iter()
.find(|(symbol, _)| rest.starts_with(symbol))?;
let version = rest[symbol.len()..].trim();
let parts: Vec<_> = version.split('.').collect();
if !(2..=3).contains(&parts.len())
|| parts
.iter()
.any(|p| p.is_empty() || !p.bytes().all(|b| b.is_ascii_digit()))
{
return None;
}
dep.comparator = Some(comparator);
dep.version = Some(version.into());
}
Some(dep)
}
pub fn parse_dependencies(list: &[String]) -> Vec<Dependency> {
list.iter().filter_map(|s| parse_dependency(s)).collect()
}
pub fn satisfies(version: &str, dep: &Dependency) -> bool {
let (Some(comparator), Some(required)) = (dep.comparator, dep.version.as_deref()) else {
return true;
};
let cmp = compare_versions(version, required);
match comparator {
Comparator::Less => cmp.is_lt(),
Comparator::LessEqual => !cmp.is_gt(),
Comparator::Equal => cmp.is_eq(),
Comparator::GreaterEqual => !cmp.is_lt(),
Comparator::Greater => cmp.is_gt(),
}
}
/// Required dependencies (no prefix or `~`) that `is_active` rejects, in declared order. Optional,
/// hidden-optional and incompatible entries never count.
pub fn missing_required(
dependencies: &[Dependency],
is_active: impl Fn(&str) -> bool,
) -> Vec<&Dependency> {
dependencies
.iter()
.filter(|d| {
matches!(
d.kind,
DependencyKind::Required | DependencyKind::NoLoadOrder
)
})
.filter(|d| !is_active(&d.name))
.collect()
}
#[cfg(test)]
mod missing_required_tests {
use super::*;
#[test]
fn lists_only_inactive_required_and_no_load_order_dependencies() {
let deps = parse_dependencies(
&["base", "a >= 1.0", "~ b", "? c", "(?) d", "! e", "f"].map(String::from),
);
let names = |active: &[&str]| {
missing_required(&deps, |n| active.contains(&n))
.iter()
.map(|d| d.name.as_str())
.collect::<Vec<_>>()
};
assert_eq!(names(&[]), ["base", "a", "b", "f"]);
assert_eq!(names(&["base", "a", "f", "c", "e"]), ["b"]);
assert!(names(&["base", "a", "b", "f"]).is_empty());
}
}