use regex::Regex;
use std::cmp::{Ordering, max};
#[derive(Debug, Clone, PartialEq)]
enum ParamPattern {
Simple { value: u64 },
Braced {
start: u64,
end: u64,
step: u64,
width: usize,
},
Bracket {
start: u64,
end: u64,
step: u64,
width: usize,
},
AlphaBracket {
start: String,
end: String,
step: u64,
width: usize,
},
Choice { values: Vec<String> },
}
fn find_param_patterns(uri: &str) -> Vec<(usize, ParamPattern)> {
let mut patterns = Vec::new();
let simple_re = Regex::new(r"\$(\d+)").unwrap();
for cap in simple_re.captures_iter(uri) {
let full_match = cap.get(0).unwrap();
let start = full_match.start();
if start > 0 {
let prev_char = uri.as_bytes()[start - 1];
if prev_char == b'{' || prev_char == b'$' {
continue;
}
}
let digits = cap.get(1).unwrap().as_str();
let value: u64 = digits.parse().unwrap_or(1);
patterns.push((start, ParamPattern::Simple { value }));
}
let choice_re = Regex::new(r"\{([^{}]+,[^{}]+)\}").unwrap();
for cap in choice_re.captures_iter(uri) {
patterns.push((
cap.get(0).unwrap().start(),
ParamPattern::Choice {
values: cap[1].split(',').map(str::to_owned).collect(),
},
));
}
let braced_re = Regex::new(r"\$\{([^}]+)\}").unwrap();
for cap in braced_re.captures_iter(uri) {
let full_match = cap.get(0).unwrap();
let inner = cap.get(1).unwrap().as_str();
let pattern = match parse_braced_pattern(inner) {
Some(pattern) => pattern,
None => continue,
};
patterns.push((full_match.start(), pattern));
}
let bracket_re = Regex::new(r"\[([A-Za-z0-9]+)-([A-Za-z0-9]+)(?::([0-9]+))?\]").unwrap();
for cap in bracket_re.captures_iter(uri) {
let full_match = cap.get(0).unwrap();
let before_bracket = &uri[..full_match.start()];
if before_bracket.ends_with(':') && before_bracket.contains("::") {
continue; }
let start_str = cap.get(1).unwrap().as_str();
let end_str = cap.get(2).unwrap().as_str();
let step_str = cap.get(3).map(|m| m.as_str());
let step = step_str.and_then(|s| s.parse::<u64>().ok()).unwrap_or(1);
if step == 0 {
continue;
}
if let (Ok(start), Ok(end)) = (start_str.parse::<u64>(), end_str.parse::<u64>()) {
patterns.push((
full_match.start(),
ParamPattern::Bracket {
start,
end,
step,
width: max(start_str.len(), end_str.len()),
},
));
} else if is_alpha_range(start_str, end_str) {
patterns.push((
full_match.start(),
ParamPattern::AlphaBracket {
start: start_str.to_string(),
end: end_str.to_string(),
step,
width: start_str.len(),
},
));
}
}
patterns.sort_by_key(|(pos, _)| *pos);
patterns
}
fn parse_braced_pattern(inner: &str) -> Option<ParamPattern> {
if let Some(cap) = Regex::new(r"^(\d+)-(\d+):(\d+)$").unwrap().captures(inner) {
let start: u64 = cap[1].parse().ok()?;
let end: u64 = cap[2].parse().ok()?;
let step: u64 = cap[3].parse().ok()?;
if step == 0 {
return None;
}
let width = cap[1].len();
return Some(ParamPattern::Braced {
start,
end,
step,
width,
});
}
if let Some(cap) = Regex::new(r"^(\d+)-(\d+)$").unwrap().captures(inner) {
let start: u64 = cap[1].parse().ok()?;
let end: u64 = cap[2].parse().ok()?;
let width = cap[1].len();
return Some(ParamPattern::Braced {
start,
end,
step: 1,
width,
});
}
if let Some(cap) = Regex::new(r"^(\d+)$").unwrap().captures(inner) {
let count: u64 = cap[1].parse().ok()?;
let width = cap[1].len();
return Some(ParamPattern::Braced {
start: 1,
end: count,
step: 1,
width,
});
}
None
}
fn is_alpha_range(start: &str, end: &str) -> bool {
!start.is_empty()
&& start.len() == end.len()
&& ((start.bytes().all(|b| b.is_ascii_lowercase())
&& end.bytes().all(|b| b.is_ascii_lowercase()))
|| (start.bytes().all(|b| b.is_ascii_uppercase())
&& end.bytes().all(|b| b.is_ascii_uppercase())))
}
fn alpha_value(value: &str) -> u32 {
value.bytes().fold(0, |acc, byte| {
acc * 26 + u32::from(byte.to_ascii_lowercase() - b'a' + 1)
})
}
fn alpha_string(mut value: u32, uppercase: bool, width: usize) -> String {
let mut bytes = Vec::new();
while value > 0 {
value -= 1;
bytes.push((b'a' + (value % 26) as u8) as char);
value /= 26;
}
while bytes.len() < width {
bytes.push('a');
}
bytes.reverse();
let result: String = bytes.into_iter().collect();
if uppercase {
result.to_ascii_uppercase()
} else {
result
}
}
fn generate_alpha_range(start: &str, end: &str, step: u64, width: usize) -> Vec<String> {
if step == 0 {
return Vec::new();
}
let start_value = alpha_value(start);
let end_value = alpha_value(end);
let uppercase = start.bytes().next().is_some_and(|b| b.is_ascii_uppercase());
let mut value = start_value;
let mut result = Vec::new();
while value <= end_value {
result.push(alpha_string(value, uppercase, width));
value = match value.checked_add(step as u32) {
Some(next) => next,
None => break,
};
}
result
}
fn format_with_width(n: u64, width: usize) -> String {
format!("{:0width$}", n, width = width)
}
fn expand_pattern(pattern: &ParamPattern) -> Vec<String> {
match pattern {
ParamPattern::Simple { value } => {
let count = 10u64.pow(*value as u32);
(1..=count).map(|n| n.to_string()).collect()
}
ParamPattern::Braced {
start,
end,
step,
width,
} => generate_range(*start, *end, *step, *width),
ParamPattern::Bracket {
start,
end,
step,
width,
} => generate_range(*start, *end, *step, *width),
ParamPattern::AlphaBracket {
start,
end,
step,
width,
} => generate_alpha_range(start, end, *step, *width),
ParamPattern::Choice { values } => {
values.iter().map(|value| value.trim().to_owned()).collect()
}
}
}
fn generate_range(start: u64, end: u64, step: u64, width: usize) -> Vec<String> {
if step == 0 {
return Vec::new();
}
let mut values = Vec::new();
match start.cmp(&end) {
Ordering::Less => {
let mut current = start;
while current <= end {
values.push(format_with_width(current, width));
current += step;
}
}
Ordering::Greater => {
let mut current = start;
while current >= end {
values.push(format_with_width(current, width));
if current < step {
break; }
current -= step;
}
}
Ordering::Equal => {
values.push(format_with_width(start, width));
}
}
values
}
pub fn expand_parameterized_uri(uri: &str) -> Vec<String> {
let patterns = find_param_patterns(uri);
if patterns.is_empty() {
return vec![uri.to_string()];
}
let mut all_expansions: Vec<Vec<String>> = Vec::new();
for (_, pattern) in &patterns {
match pattern {
ParamPattern::Simple { value } => {
let count = 10u64.pow(*value as u32);
let values: Vec<String> = (1..=count).map(|n| n.to_string()).collect();
all_expansions.push(values);
}
_ => {
let values = expand_pattern(pattern);
if values.is_empty() {
return vec![uri.to_string()];
}
all_expansions.push(values);
}
}
}
if all_expansions.is_empty() {
return vec![uri.to_string()];
}
let mut template = uri.to_string();
for (index, (position, pattern)) in patterns.iter().enumerate().rev() {
let start = *position;
let end = start + pattern_source_len(&uri[start..], pattern);
template.replace_range(start..end, &format!("\u{1f}{index}\u{1f}"));
}
cartesian_product_replace(&template, &all_expansions)
}
fn cartesian_product_replace(uri: &str, expansions: &[Vec<String>]) -> Vec<String> {
let mut results = vec![uri.to_string()];
for (index, expansion_set) in expansions.iter().enumerate() {
let marker = format!("\u{1f}{index}\u{1f}");
let mut next = Vec::with_capacity(results.len() * expansion_set.len());
for result in &results {
for value in expansion_set {
next.push(result.replacen(&marker, value, 1));
}
}
results = next;
}
results
}
fn pattern_source_len(source: &str, pattern: &ParamPattern) -> usize {
match pattern {
ParamPattern::Simple { .. } => {
1 + source[1..].bytes().take_while(u8::is_ascii_digit).count()
}
ParamPattern::Braced { .. } | ParamPattern::Choice { .. } => {
source.find('}').map_or(0, |end| end + 1)
}
ParamPattern::Bracket { .. } | ParamPattern::AlphaBracket { .. } => {
source.find(']').map_or(0, |end| end + 1)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
include!("param_expander_tests.rs");
}