#[cfg_attr(test, allow(dead_code))]
pub(crate) fn extract_version_from_template(
template: &str,
captures: ®ex::Captures,
) -> Option<String> {
if !template.starts_with("version:") {
return None;
}
let version_expr = template.strip_prefix("version:").unwrap_or("").trim();
if version_expr.is_empty() {
return None;
}
let mut placeholders_in_template = std::collections::HashSet::new();
for i in 1..=99 {
let placeholder_double = format!("\\\\{i}");
let placeholder_single = format!("\\{i}");
if version_expr.contains(&placeholder_double) || version_expr.contains(&placeholder_single)
{
placeholders_in_template.insert(i);
}
}
static RE_PLACEHOLDER: std::sync::LazyLock<regex::Regex> =
std::sync::LazyLock::new(|| regex::Regex::new(r"\\\d+").expect("placeholder regex"));
let mut result = if version_expr.contains('?') {
evaluate_version_ternary(version_expr, captures)
} else {
let mut res = version_expr.to_string();
for i in (1..captures.len()).rev() {
if placeholders_in_template.contains(&i) {
if let Some(cap_value) = captures.get(i) {
let placeholder_double = format!("\\\\{i}");
let placeholder_single = format!("\\{i}");
res = res.replace(&placeholder_double, cap_value.as_str());
res = res.replace(&placeholder_single, cap_value.as_str());
}
}
}
RE_PLACEHOLDER.replace_all(&res, "").to_string()
};
result = RE_PLACEHOLDER.replace_all(&result, "").to_string();
if result.is_empty() {
None
} else {
let trimmed = result.trim().to_string();
if trimmed.contains(';') {
let has_multiple_placeholders = placeholders_in_template.len() > 1;
if !has_multiple_placeholders {
let first_part = trimmed.split(';').next().unwrap_or(&trimmed).trim();
if !first_part.is_empty() {
return Some(first_part.to_string());
}
}
}
Some(trimmed)
}
}
pub(super) fn replace_placeholders(template: &str, captures: ®ex::Captures) -> String {
let mut result = template.to_string();
for i in (1..captures.len()).rev() {
if let Some(cap_value) = captures.get(i) {
let placeholder_double = format!("\\\\{i}");
let placeholder_single = format!("\\{i}");
result = result.replace(&placeholder_double, cap_value.as_str());
result = result.replace(&placeholder_single, cap_value.as_str());
}
}
result
}
pub(super) fn parse_ternary_expression(expression: &str) -> Option<(&str, &str)> {
if !expression.contains('?') {
return None;
}
let parts: Vec<&str> = expression.splitn(2, '?').collect();
let after_question = parts.get(1)?;
let true_false_parts: Vec<&str> = after_question.splitn(2, ':').collect();
match (true_false_parts.first(), true_false_parts.get(1)) {
(Some(true_val), Some(false_val)) => Some((true_val, false_val)),
_ => None,
}
}
pub(super) fn evaluate_version_ternary(expression: &str, captures: ®ex::Captures) -> String {
let Some((true_part, false_part)) = parse_ternary_expression(expression) else {
return expression.to_string();
};
let has_capture_groups = captures.len() > 1;
if true_part.is_empty() {
if false_part.is_empty() {
String::new()
} else {
replace_placeholders(false_part, captures)
}
} else {
if has_capture_groups {
replace_placeholders(true_part, captures)
} else {
replace_placeholders(false_part, captures)
}
}
}