mod version;
use moka::sync::Cache;
use std::collections::HashMap;
use std::sync::LazyLock;
const MAX_REGEX_CACHE_SIZE: u64 = 10_000;
static REGEX_CACHE: LazyLock<Cache<String, regex::Regex>> =
LazyLock::new(|| Cache::new(MAX_REGEX_CACHE_SIZE));
pub(crate) const MIN_PATTERN_CONFIDENCE: u32 = 50;
#[derive(Debug, Clone)]
pub(crate) struct MetaMatchResult {
pub matched: bool,
pub version: Option<String>,
}
pub(crate) fn check_meta_patterns(
meta_key: &str,
patterns: &[String],
meta_tags: &HashMap<String, Vec<String>>,
) -> MetaMatchResult {
let meta_key_lower = meta_key.to_lowercase();
let check_patterns = |meta_values: &[String]| -> MetaMatchResult {
let mut matched_version: Option<String> = None;
let mut has_match = false;
for meta_value in meta_values {
for pattern in patterns {
let result = matches_pattern(pattern, meta_value);
if result.matched {
has_match = true;
if matched_version.is_none() && result.version.is_some() {
matched_version.clone_from(&result.version);
}
if matched_version.is_some() {
break;
}
}
}
if matched_version.is_some() {
break;
}
}
MetaMatchResult {
matched: has_match,
version: matched_version,
}
};
if meta_key_lower.starts_with("property:") {
let key_without_prefix = meta_key_lower
.strip_prefix("property:")
.unwrap_or(&meta_key_lower);
if let Some(meta_value) = meta_tags.get(&format!("property:{key_without_prefix}")) {
let result = check_patterns(meta_value);
if result.matched {
return result;
}
}
} else if meta_key_lower.starts_with("http-equiv:") {
let key_without_prefix = meta_key_lower
.strip_prefix("http-equiv:")
.unwrap_or(&meta_key_lower);
if let Some(meta_value) = meta_tags.get(&format!("http-equiv:{key_without_prefix}")) {
let result = check_patterns(meta_value);
if result.matched {
return result;
}
}
} else {
if let Some(meta_value) = meta_tags.get(&format!("name:{meta_key_lower}")) {
let result = check_patterns(meta_value);
if result.matched {
return result;
}
}
if let Some(meta_value) = meta_tags.get(&format!("property:{meta_key_lower}")) {
let result = check_patterns(meta_value);
if result.matched {
return result;
}
}
if let Some(meta_value) = meta_tags.get(&format!("http-equiv:{meta_key_lower}")) {
let result = check_patterns(meta_value);
if result.matched {
return result;
}
}
}
MetaMatchResult {
matched: false,
version: None,
}
}
#[derive(Debug, Clone)]
pub(crate) struct PatternMatchResult {
pub matched: bool,
pub version: Option<String>,
}
struct ParsedPattern {
pattern_for_match: String,
version_template: Option<String>,
confidence: u32,
}
#[cfg_attr(test, allow(dead_code))]
fn parse_pattern(pattern: &str) -> ParsedPattern {
let parts: Vec<&str> = pattern.split("\\;").collect();
let pattern_for_match = parts[0].trim().to_string();
let mut version_template: Option<String> = None;
let mut confidence: u32 = 100;
for part in parts.iter().skip(1) {
if let Some(colon_pos) = part.find(':') {
let key = &part[..colon_pos];
let value = &part[colon_pos + 1..];
if key == "version" && version_template.is_none() {
version_template = Some(value.to_string());
} else if key == "confidence" {
if let Ok(n) = value.trim().parse::<u32>() {
confidence = n;
}
}
}
}
ParsedPattern {
pattern_for_match,
version_template,
confidence,
}
}
#[must_use]
pub(crate) fn parse_technology_reference(raw: &str) -> (String, Option<String>) {
let parsed = parse_pattern(raw);
(parsed.pattern_for_match, parsed.version_template)
}
fn is_regex_pattern(pattern: &str) -> bool {
pattern.starts_with('^')
|| pattern.contains('$')
|| pattern.contains('\\')
|| pattern.contains('[')
|| pattern.contains('(')
|| pattern.contains('*')
|| pattern.contains('+')
|| pattern.contains('?')
}
pub(crate) fn get_or_compile_regex(pattern: &str, cache_key: &str) -> Option<regex::Regex> {
let case_insensitive_pattern = format!("(?i){pattern}");
if let Some(cached) = REGEX_CACHE.get(cache_key) {
return Some(cached);
}
match regex::Regex::new(&case_insensitive_pattern) {
Ok(re) => {
REGEX_CACHE.insert(cache_key.to_string(), re.clone());
Some(re)
}
Err(_) => None, }
}
fn handle_empty_pattern(version_template: Option<&str>) -> PatternMatchResult {
let version = if let Some(template) = version_template {
let template = template.trim();
if template.is_empty() {
None
} else {
if !template.contains('\\') || !template.chars().any(|c| c.is_ascii_digit()) {
Some(template.to_string())
} else {
None
}
}
} else {
None
};
PatternMatchResult {
matched: true,
version,
}
}
pub(crate) fn matches_pattern(pattern: &str, text: &str) -> PatternMatchResult {
let parsed = parse_pattern(pattern);
if parsed.confidence < MIN_PATTERN_CONFIDENCE {
return PatternMatchResult {
matched: false,
version: None,
};
}
if parsed.pattern_for_match.is_empty() {
return handle_empty_pattern(parsed.version_template.as_deref());
}
let is_regex = is_regex_pattern(&parsed.pattern_for_match);
if is_regex {
let cache_key = parsed.pattern_for_match.clone();
let Some(re) = get_or_compile_regex(&parsed.pattern_for_match, &cache_key) else {
return PatternMatchResult {
matched: false,
version: None,
};
};
if let Some(captures) = re.captures(text) {
let version = if let Some(template) = &parsed.version_template {
extract_version_from_template(&format!("version:{template}"), &captures)
} else {
None
};
PatternMatchResult {
matched: true,
version,
}
} else {
PatternMatchResult {
matched: false,
version: None,
}
}
} else {
let escaped_pattern = regex::escape(&parsed.pattern_for_match);
let cache_key = parsed.pattern_for_match.clone();
let Some(re) = get_or_compile_regex(&escaped_pattern, &cache_key) else {
return PatternMatchResult {
matched: false,
version: None,
};
};
PatternMatchResult {
matched: re.is_match(text),
version: None,
}
}
}
use version::*;
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{Mutex, OnceLock};
fn cache_test_lock() -> std::sync::MutexGuard<'static, ()> {
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
LOCK.get_or_init(|| Mutex::new(()))
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
fn clear_regex_cache() {
REGEX_CACHE.invalidate_all();
}
#[test]
fn test_matches_pattern_empty_pattern() {
assert!(matches_pattern("", "anything").matched);
assert!(matches_pattern("", "").matched);
assert!(matches_pattern("", "test string").matched);
}
#[test]
fn test_matches_pattern_simple_substring() {
assert!(matches_pattern("nginx", "nginx/1.18.0").matched);
assert!(matches_pattern("WordPress", "Powered by WordPress").matched); assert!(matches_pattern("wordpress", "Powered by WordPress").matched); assert!(matches_pattern("WORDPRESS", "Powered by WordPress").matched); assert!(!matches_pattern("apache", "nginx/1.18.0").matched);
assert!(!matches_pattern("nginx", "apache/2.4").matched);
}
#[test]
fn test_matches_pattern_regex_starts_with_caret() {
assert!(matches_pattern("^nginx", "nginx/1.18.0").matched);
assert!(!matches_pattern("^nginx", "server: nginx/1.18.0").matched);
}
#[test]
fn test_matches_pattern_regex_ends_with_dollar() {
assert!(matches_pattern("nginx$", "nginx").matched);
assert!(!matches_pattern("nginx$", "nginx/1.18.0").matched);
}
#[test]
fn test_matches_pattern_regex_special_chars() {
assert!(matches_pattern("nginx.*", "nginx/1.18.0").matched);
assert!(matches_pattern("wordpress\\+", "wordpress+").matched);
assert!(matches_pattern("test\\?", "test?").matched);
assert!(matches_pattern("[0-9]+", "version 123").matched);
}
#[test]
fn test_matches_pattern_version_extraction() {
let result1 = matches_pattern(
"jquery(?:-(\\d+\\.\\d+\\.\\d+))[/.-]\\;version:\\1",
"jquery-3.6.0.min.js",
);
assert!(result1.matched);
assert_eq!(result1.version, Some("3.6.0".to_string()));
let result2 = matches_pattern("^wordpress\\;version:\\1$", "wordpress");
assert!(result2.matched);
}
#[test]
fn test_check_meta_patterns_simple_name() {
let mut meta_tags = HashMap::new();
meta_tags.insert("name:generator".to_string(), vec!["WordPress".to_string()]);
assert!(check_meta_patterns("generator", &["WordPress".to_string()], &meta_tags).matched);
assert!(!check_meta_patterns("generator", &["Drupal".to_string()], &meta_tags).matched);
}
#[test]
fn test_check_meta_patterns_property_prefix() {
let mut meta_tags = HashMap::new();
meta_tags.insert(
"property:og:title".to_string(),
vec!["My Title".to_string()],
);
assert!(
check_meta_patterns("property:og:title", &["My Title".to_string()], &meta_tags).matched
);
assert!(
!check_meta_patterns(
"property:og:title",
&["Other Title".to_string()],
&meta_tags
)
.matched
);
}
#[test]
fn test_check_meta_patterns_http_equiv_prefix() {
let mut meta_tags = HashMap::new();
meta_tags.insert(
"http-equiv:content-type".to_string(),
vec!["text/html".to_string()],
);
assert!(
check_meta_patterns(
"http-equiv:content-type",
&["text/html".to_string()],
&meta_tags
)
.matched
);
}
#[test]
fn test_check_meta_patterns_tries_all_prefixes() {
let mut meta_tags = HashMap::new();
meta_tags.insert(
"property:generator".to_string(),
vec!["WordPress".to_string()],
);
assert!(check_meta_patterns("generator", &["WordPress".to_string()], &meta_tags).matched);
}
#[test]
fn test_check_meta_patterns_case_insensitive_key() {
let mut meta_tags = HashMap::new();
meta_tags.insert("name:generator".to_string(), vec!["WordPress".to_string()]);
assert!(check_meta_patterns("GENERATOR", &["WordPress".to_string()], &meta_tags).matched);
}
#[test]
fn test_check_meta_patterns_multiple_patterns() {
let mut meta_tags = HashMap::new();
meta_tags.insert(
"name:generator".to_string(),
vec!["WordPress 5.0".to_string()],
);
assert!(
check_meta_patterns(
"generator",
&["Drupal".to_string(), "WordPress".to_string()],
&meta_tags
)
.matched
);
}
#[test]
fn test_check_meta_patterns_empty_meta_tags() {
let meta_tags = HashMap::new();
assert!(!check_meta_patterns("generator", &["WordPress".to_string()], &meta_tags).matched);
}
#[test]
fn test_check_meta_patterns_empty_patterns() {
let mut meta_tags = HashMap::new();
meta_tags.insert("name:generator".to_string(), vec!["WordPress".to_string()]);
assert!(!check_meta_patterns("generator", &[], &meta_tags).matched);
}
#[test]
fn test_check_meta_patterns_regex_in_patterns() {
let mut meta_tags = HashMap::new();
meta_tags.insert(
"name:generator".to_string(),
vec!["WordPress 5.0".to_string()],
);
assert!(check_meta_patterns("generator", &["^WordPress".to_string()], &meta_tags).matched);
}
#[test]
fn test_regex_cache_works() {
let _guard = cache_test_lock();
use std::time::{SystemTime, UNIX_EPOCH};
let stamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
let pattern = format!("^nginx_cache_works_{stamp}");
let text = format!("nginx_cache_works_{stamp}/1.18.0");
assert!(matches_pattern(&pattern, &text).matched);
assert!(matches_pattern(&pattern, &text).matched);
assert!(
REGEX_CACHE.get(&pattern).is_some(),
"Cache should contain compiled regex for '{pattern}'"
);
}
#[test]
fn test_regex_cache_thread_safety() {
let _guard = cache_test_lock();
use std::time::{SystemTime, UNIX_EPOCH};
let timestamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
let test_prefix = format!("thread_safety_test_{}_", timestamp);
use std::thread;
let patterns: Vec<String> = (0..10).map(|i| format!("^{}{}", test_prefix, i)).collect();
for (i, pattern) in patterns.iter().enumerate() {
let text = format!("{}{}value", test_prefix, i);
assert!(
matches_pattern(pattern, &text).matched,
"Pattern '{}' should match text '{}'",
pattern,
text
);
}
let handles: Vec<_> = patterns
.iter()
.enumerate()
.map(|(i, pattern)| {
let pattern_clone = pattern.clone();
let prefix_clone = test_prefix.clone();
thread::spawn(move || {
let text = format!("{}{}value", prefix_clone, i);
let result1 = matches_pattern(&pattern_clone, &text);
let result2 = matches_pattern(&pattern_clone, &text);
assert_eq!(
result1.matched, result2.matched,
"Cached and uncached calls should return same result"
);
result1
})
})
.collect();
for handle in handles {
assert!(
handle.join().unwrap().matched,
"Thread should return true for pattern match"
);
}
}
#[test]
fn test_regex_cache_benchmark() {
let _guard = cache_test_lock();
clear_regex_cache();
let pattern = "^nginx.*version";
let text = "nginx/1.18.0 version";
let start = std::time::Instant::now();
for _ in 0..1000 {
clear_regex_cache();
let _ = matches_pattern(pattern, text);
}
let without_cache_time = start.elapsed();
clear_regex_cache();
let start = std::time::Instant::now();
for _ in 0..1000 {
let _ = matches_pattern(pattern, text);
}
let with_cache_time = start.elapsed();
assert!(
with_cache_time < without_cache_time,
"Cached version should be faster. Without cache: {:?}, With cache: {:?}",
without_cache_time,
with_cache_time
);
#[allow(clippy::cast_precision_loss)]
let speedup = if with_cache_time.as_nanos() > 0 {
without_cache_time.as_nanos() as f64 / with_cache_time.as_nanos() as f64
} else {
0.0 };
println!(
"Regex cache benchmark: Without cache: {:?}, With cache: {:?}, Speedup: {:.2}x",
without_cache_time, with_cache_time, speedup
);
}
#[test]
fn test_matches_pattern_invalid_regex_is_skipped() {
assert!(!matches_pattern("[unclosed", "text with [unclosed bracket").matched);
assert!(!matches_pattern("[unclosed", "text without pattern").matched);
assert!(!matches_pattern(r"\invalid", r"text with \invalid").matched);
assert!(!matches_pattern("(unclosed", "text with (unclosed paren").matched);
assert!(matches_pattern("test{invalid", "text with test{invalid").matched);
}
#[test]
fn test_check_meta_patterns_malformed_prefix() {
let mut meta_tags = HashMap::new();
meta_tags.insert("name:generator".to_string(), vec!["WordPress".to_string()]);
assert!(
!check_meta_patterns(
"property:property:og:title",
&["WordPress".to_string()],
&meta_tags
)
.matched
);
assert!(!check_meta_patterns("property:", &["WordPress".to_string()], &meta_tags).matched);
}
#[test]
fn test_matches_pattern_very_long_string() {
let very_long_text = "A".repeat(1_000_000);
let pattern = "test";
let result = matches_pattern(pattern, &very_long_text);
assert!(
!result.matched,
"Pattern should not match in very long string"
);
}
#[test]
fn test_matches_pattern_special_regex_chars_in_substring() {
let text = "test[pattern]with(special)chars";
assert!(matches_pattern("[pattern]", text).matched);
assert!(matches_pattern("(special)", text).matched);
assert!(matches_pattern("chars", text).matched);
}
#[test]
fn test_matches_pattern_version_extraction_complex() {
let pattern = r"^nginx/(\d+\.\d+)\;version:\1";
let text = "nginx/1.18.0";
let result = matches_pattern(pattern, text);
assert!(result.matched, "Pattern should match 'nginx/1.18.0'");
assert_eq!(result.version, Some("1.18".to_string()));
}
#[test]
fn test_matches_pattern_regex_anchors_edge_cases() {
assert!(matches_pattern("^start", "start of text").matched);
assert!(!matches_pattern("^start", "text with start").matched);
assert!(matches_pattern("end$", "text with end").matched);
assert!(!matches_pattern("end$", "end of text with more").matched);
assert!(matches_pattern("^exact$", "exact").matched);
assert!(!matches_pattern("^exact$", "not exact").matched);
}
#[test]
fn test_check_meta_patterns_empty_patterns_vector() {
let mut meta_tags = HashMap::new();
meta_tags.insert("name:generator".to_string(), vec!["WordPress".to_string()]);
assert!(!check_meta_patterns("generator", &[], &meta_tags).matched);
}
#[test]
fn test_check_meta_patterns_multiple_prefixes_same_key() {
let mut meta_tags = HashMap::new();
meta_tags.insert("name:test".to_string(), vec!["value1".to_string()]);
meta_tags.insert("property:test".to_string(), vec!["value2".to_string()]);
meta_tags.insert("http-equiv:test".to_string(), vec!["value3".to_string()]);
assert!(check_meta_patterns("test", &["value1".to_string()], &meta_tags).matched);
assert!(check_meta_patterns("test", &["value2".to_string()], &meta_tags).matched);
assert!(check_meta_patterns("test", &["value3".to_string()], &meta_tags).matched);
}
#[test]
fn test_check_meta_patterns_wordpress_version_extraction() {
let mut meta_tags = HashMap::new();
meta_tags.insert(
"name:generator".to_string(),
vec!["WordPress 6.8.3".to_string()],
);
let result = check_meta_patterns(
"generator",
&[r"^wordpress(?: ([\d.]+))?\;version:\1".to_string()],
&meta_tags,
);
assert!(result.matched, "Should match WordPress generator meta tag");
assert_eq!(
result.version,
Some("6.8.3".to_string()),
"Should extract WordPress version 6.8.3"
);
}
#[test]
fn test_matches_pattern_with_version_template() {
let pattern = r"^version ([\d.]+)\;version:\1";
let text = "version 5.0";
let result = matches_pattern(pattern, text);
assert!(result.matched, "Should match pattern");
assert_eq!(
result.version,
Some("5.0".to_string()),
"Should extract version 5.0"
);
}
#[test]
fn test_matches_pattern_ignores_non_version_template() {
let pattern = r"^test\;metadata:value";
let text = "test";
let result = matches_pattern(pattern, text);
assert!(result.matched, "Should match pattern");
assert_eq!(
result.version, None,
"Should not extract version when template doesn't start with 'version:'"
);
}
#[test]
fn test_parse_pattern_extracts_version_template() {
let pattern = r"nginx/(\d+\.\d+)\;version:\1";
let result = matches_pattern(pattern, "nginx/1.18.0");
assert!(result.matched);
assert_eq!(result.version, Some("1.18".to_string()));
}
#[test]
fn test_parse_pattern_respects_confidence_threshold() {
let low = matches_pattern(r"jquery\;confidence:49", "jquery.min.js");
assert!(!low.matched);
let ok = matches_pattern(r"jquery\;confidence:50", "jquery.min.js");
assert!(ok.matched);
assert_eq!(ok.version, None);
}
#[test]
fn test_is_regex_pattern_detection() {
assert!(matches_pattern("^nginx", "nginx/1.18.0").matched);
assert!(!matches_pattern("^nginx", "server: nginx/1.18.0").matched);
assert!(matches_pattern("nginx$", "nginx").matched);
assert!(!matches_pattern("nginx$", "nginx/1.18.0").matched);
assert!(matches_pattern("nginx.*", "nginx/1.18.0").matched);
}
#[test]
fn test_get_or_compile_regex_caching() {
let _guard = cache_test_lock();
use std::time::{SystemTime, UNIX_EPOCH};
let stamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
let pattern = format!("^test_pattern_cache_{stamp}");
let text = format!("test_pattern_cache_{stamp}_value");
assert!(
REGEX_CACHE.get(&pattern).is_none(),
"Cache should not contain the unique pattern before first use"
);
assert!(matches_pattern(&pattern, &text).matched);
assert!(
REGEX_CACHE.get(&pattern).is_some(),
"Cache should contain compiled regex after first use"
);
assert!(matches_pattern(&pattern, &text).matched);
}
#[test]
fn test_regex_cache_eviction() {
let _guard = cache_test_lock();
use std::hash::{Hash, Hasher};
use std::time::{SystemTime, UNIX_EPOCH};
let timestamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
let mut hasher = std::collections::hash_map::DefaultHasher::new();
std::thread::current().id().hash(&mut hasher);
let thread_hash = hasher.finish();
let unique_suffix = format!("{}_{}", timestamp, thread_hash);
let pattern1 = format!("^evict_test_{}_1", unique_suffix);
let pattern2 = format!("^evict_test_{}_2", unique_suffix);
let pattern3 = format!("^evict_test_{}_3", unique_suffix);
assert!(
matches_pattern(&pattern1, &format!("evict_test_{}_1_value", unique_suffix)).matched,
"Pattern 1 should match on first use"
);
assert!(
matches_pattern(&pattern2, &format!("evict_test_{}_2_value", unique_suffix)).matched,
"Pattern 2 should match on first use"
);
assert!(
matches_pattern(&pattern3, &format!("evict_test_{}_3_value", unique_suffix)).matched,
"Pattern 3 should match on first use"
);
assert!(
matches_pattern(&pattern1, &format!("evict_test_{}_1_value", unique_suffix)).matched,
"Pattern 1 should match on second use (cached)"
);
assert!(
matches_pattern(&pattern2, &format!("evict_test_{}_2_value", unique_suffix)).matched,
"Pattern 2 should match on second use (cached)"
);
assert!(
matches_pattern(&pattern3, &format!("evict_test_{}_3_value", unique_suffix)).matched,
"Pattern 3 should match on second use (cached)"
);
assert!(
!matches_pattern(&pattern1, "completely_different_value").matched,
"Pattern should not match unrelated text"
);
}
#[test]
fn test_handle_empty_pattern_with_literal_version() {
let pattern = r"\;version:ga4";
let result = matches_pattern(pattern, "anything");
assert!(result.matched, "Empty pattern should match anything");
assert_eq!(result.version, Some("ga4".to_string()));
}
#[test]
fn test_handle_empty_pattern_without_version() {
let pattern = "";
let result = matches_pattern(pattern, "anything");
assert!(result.matched, "Empty pattern should match anything");
assert_eq!(result.version, None);
}
#[test]
fn test_get_or_compile_regex_skips_invalid_regex() {
let pattern = "[invalid"; let result = matches_pattern(pattern, "text with [invalid bracket");
assert!(!result.matched);
assert_eq!(result.version, None);
}
#[test]
fn test_replace_placeholders_simple() {
let pattern = r"nginx/(\d+\.\d+)\;version:\1";
let result = matches_pattern(pattern, "nginx/1.18.0");
assert!(result.matched);
assert_eq!(result.version, Some("1.18".to_string()));
}
#[test]
fn test_replace_placeholders_multiple_groups() {
let pattern = r"(\d+)\.(\d+)\;version:\1.\2";
let result = matches_pattern(pattern, "1.18");
assert!(result.matched);
assert_eq!(result.version, Some("1.18".to_string()));
}
#[test]
fn test_parse_ternary_expression_valid() {
let pattern = r"(\d+)?(\d+)\;version:\1?\1:\2";
let result = matches_pattern(pattern, "18");
assert!(result.matched);
}
#[test]
fn test_ternary_evaluated_before_placeholder_replacement() {
let pattern = r"^(beta:v\d+)(\.\d+)?\;version:\1?\1:\2";
let result = matches_pattern(pattern, "beta:v2");
assert!(result.matched, "Pattern should match");
assert_eq!(
result.version,
Some("beta:v2".to_string()),
"Version must be intact, not split on ':' by ternary parser"
);
}
#[test]
fn test_parse_ternary_expression_invalid() {
let pattern = r"test\;version:\1?\1";
let result = matches_pattern(pattern, "test");
assert!(result.matched);
}
#[test]
fn test_evaluate_version_ternary_with_capture_groups() {
let pattern = r"(\d+)\.(\d+)\;version:\1?\1:\2";
let result = matches_pattern(pattern, "1.18");
assert!(result.matched);
assert_eq!(result.version, Some("1".to_string()));
}
#[test]
fn test_evaluate_version_ternary_without_capture_groups() {
let pattern = r"test\;version:\1?\1:fallback";
let result = matches_pattern(pattern, "test");
assert!(result.matched);
}
#[test]
fn test_evaluate_version_ternary_empty_true_part() {
let pattern = r"(\d+)\;version:?:\1";
let result = matches_pattern(pattern, "123");
assert!(result.matched);
assert_eq!(result.version, Some("123".to_string()));
}
#[test]
fn test_evaluate_version_ternary_both_parts_empty() {
let pattern = r"test\;version:?:";
let result = matches_pattern(pattern, "test");
assert!(result.matched);
assert_eq!(result.version, None);
}
#[test]
fn test_extract_version_semicolon_in_captured_value() {
let pattern = r"version (\d+);(\d+)\;version:\1";
let text = "version 64;5.3";
let result = matches_pattern(pattern, text);
assert!(result.matched);
assert_eq!(result.version, Some("64".to_string()));
}
#[test]
fn test_extract_version_multiple_placeholders_with_semicolon() {
let pattern = r"v(\d+)\.(\d+)\;version:\1;\2";
let text = "v1.2";
let result = matches_pattern(pattern, text);
assert!(result.matched);
assert!(result.version.is_some());
assert!(result.version.unwrap().contains("1"));
}
#[test]
fn test_extract_version_high_capture_group_number() {
let pattern = r"v(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\;version:\9";
let text = "v1.2.3.4.5.6.7.8.9";
let result = matches_pattern(pattern, text);
assert!(result.matched);
assert_eq!(result.version, Some("9".to_string()));
}
#[test]
fn test_extract_version_unmatched_placeholder_removed() {
let pattern = r"v(\d+)\.(\d+)\;version:\1.\2.\3";
let text = "v1.2";
let result = matches_pattern(pattern, text);
assert!(result.matched);
assert_eq!(result.version, Some("1.2.".to_string()));
}
#[test]
fn test_extract_version_reverse_order_replacement() {
let pattern =
r"v(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\d+)\;version:\10";
let text = "v1.2.3.4.5.6.7.8.9.10";
let result = matches_pattern(pattern, text);
assert!(result.matched);
if let Some(version) = result.version {
assert_ne!(version, "1");
}
}
}