1#[derive(Debug, Clone)]
2pub struct Pattern {
3 pub prefix: String,
4 pub suffix: String,
5 pub contains: String,
6 pub prefix_match: String,
7 pub suffix_match: String,
8 pub contains_match: String,
9 pub ignore_case: bool,
10}
11
12impl Pattern {
13 pub fn has_prefix(&self) -> bool {
14 !self.prefix.is_empty()
15 }
16
17 pub fn has_suffix(&self) -> bool {
18 !self.suffix.is_empty()
19 }
20
21 pub fn has_contains(&self) -> bool {
22 !self.contains.is_empty()
23 }
24
25 pub fn description(&self) -> String {
26 let mut parts = Vec::new();
27 if self.has_prefix() {
28 parts.push(format!("starting with '{}'", self.prefix));
29 }
30 if self.has_contains() {
31 parts.push(format!("containing '{}'", self.contains));
32 }
33 if self.has_suffix() {
34 parts.push(format!("ending with '{}'", self.suffix));
35 }
36 parts.join(" and ")
37 }
38
39 pub fn case_mode(&self) -> &'static str {
40 if self.ignore_case {
41 "any case"
42 } else {
43 "exact case"
44 }
45 }
46
47 pub fn effective_literal_chars(&self) -> usize {
49 literal_len(&self.prefix) + literal_len(&self.suffix) + literal_len(&self.contains)
50 }
51}
52
53pub type PatternAlternative = (Option<String>, Option<String>, Option<String>);
55
56pub fn expand_pattern_alternatives(
59 prefix: Option<&str>,
60 suffix: Option<&str>,
61 contains: Option<&str>,
62) -> Result<Vec<PatternAlternative>, String> {
63 let split = |s: Option<&str>| -> Vec<String> {
64 match s {
65 None | Some("") => vec![],
66 Some(raw) => raw
67 .split(',')
68 .map(|p| p.trim().to_string())
69 .filter(|p| !p.is_empty())
70 .collect(),
71 }
72 };
73
74 let prefixes = split(prefix);
75 let suffixes = split(suffix);
76 let contains_list = split(contains);
77
78 let multi_count = [
79 prefixes.len() > 1,
80 suffixes.len() > 1,
81 contains_list.len() > 1,
82 ]
83 .iter()
84 .filter(|&&b| b)
85 .count();
86 if multi_count > 1 {
87 return Err("comma OR is only allowed in one of --prefix, --suffix, or --contains".into());
88 }
89
90 let n = prefixes
91 .len()
92 .max(suffixes.len())
93 .max(contains_list.len())
94 .max(1);
95
96 if prefixes.is_empty() && suffixes.is_empty() && contains_list.is_empty() {
97 return Ok(vec![(None, None, None)]);
98 }
99
100 let mut out = Vec::with_capacity(n);
101 for i in 0..n {
102 let p = if prefixes.len() > 1 {
103 prefixes.get(i).cloned()
104 } else if prefixes.len() == 1 {
105 Some(prefixes[0].clone())
106 } else {
107 None
108 };
109 let s = if suffixes.len() > 1 {
110 suffixes.get(i).cloned()
111 } else if suffixes.len() == 1 {
112 Some(suffixes[0].clone())
113 } else {
114 None
115 };
116 let c = if contains_list.len() > 1 {
117 contains_list.get(i).cloned()
118 } else if contains_list.len() == 1 {
119 Some(contains_list[0].clone())
120 } else {
121 None
122 };
123 out.push((p, s, c));
124 }
125 Ok(out)
126}
127
128pub fn expected_attempts_any(per_pattern: &[f64]) -> f64 {
130 if per_pattern.is_empty() {
131 return f64::INFINITY;
132 }
133 let inv: f64 = per_pattern.iter().map(|&e| 1.0 / e.max(1.0)).sum();
134 if inv <= 0.0 {
135 f64::INFINITY
136 } else {
137 1.0 / inv
138 }
139}
140
141fn literal_len(s: &str) -> usize {
142 s.chars().filter(|c| *c != '*').count()
143}
144
145pub fn matches_at(address: &str, pattern: &str, ignore_case: bool, at_start: bool) -> bool {
146 if pattern.is_empty() {
147 return true;
148 }
149
150 if pattern.contains('*') {
151 return match_glob_affix(address, pattern, ignore_case, at_start);
152 }
153
154 let addr_bytes = address.as_bytes();
155 let pat_bytes = pattern.as_bytes();
156
157 if pat_bytes.len() > addr_bytes.len() {
158 return false;
159 }
160
161 let slice = if at_start {
162 &addr_bytes[..pat_bytes.len()]
163 } else {
164 &addr_bytes[addr_bytes.len() - pat_bytes.len()..]
165 };
166
167 if ignore_case {
168 slice.eq_ignore_ascii_case(pat_bytes)
169 } else {
170 slice == pat_bytes
171 }
172}
173
174fn match_glob_affix(address: &str, pattern: &str, ignore_case: bool, at_start: bool) -> bool {
176 let addr = if ignore_case {
177 address.to_ascii_lowercase()
178 } else {
179 address.to_string()
180 };
181 let pat = if ignore_case {
182 pattern.to_ascii_lowercase()
183 } else {
184 pattern.to_string()
185 };
186
187 let parts: Vec<&str> = pat.split('*').collect();
188 if parts.len() == 1 {
189 return if at_start {
190 addr.starts_with(&pat)
191 } else {
192 addr.ends_with(&pat)
193 };
194 }
195
196 if at_start {
198 if !parts[0].is_empty() && !addr.starts_with(parts[0]) {
199 return false;
200 }
201 return match_contains_glob(&addr, &pat);
202 }
203
204 if !parts[parts.len() - 1].is_empty() && !addr.ends_with(parts[parts.len() - 1]) {
205 return false;
206 }
207 match_contains_glob(&addr, &pat)
208}
209
210fn match_contains_glob(address: &str, pattern: &str) -> bool {
211 if !pattern.contains('*') {
212 return address.contains(pattern);
213 }
214 let parts: Vec<&str> = pattern.split('*').collect();
215 let mut rest = address;
216 for (i, part) in parts.iter().enumerate() {
217 if part.is_empty() {
218 continue;
219 }
220 if let Some(idx) = rest.find(part) {
221 if i == 0 && !pattern.starts_with('*') && idx != 0 {
222 }
224 rest = &rest[idx + part.len()..];
225 } else {
226 return false;
227 }
228 }
229 if !pattern.ends_with('*') {
230 }
232 true
233}
234
235pub fn matches_contains(address: &str, pattern: &str, ignore_case: bool) -> bool {
236 if pattern.is_empty() {
237 return true;
238 }
239 let addr = if ignore_case {
240 address.to_ascii_lowercase()
241 } else {
242 address.to_string()
243 };
244 let pat = if ignore_case {
245 pattern.to_ascii_lowercase()
246 } else {
247 pattern.to_string()
248 };
249 match_contains_glob(&addr, &pat)
250}
251
252pub fn matches_both(address: &str, prefix: &str, suffix: &str, ignore_case: bool) -> bool {
253 matches_at(address, prefix, ignore_case, true)
254 && matches_at(address, suffix, ignore_case, false)
255}
256
257pub fn matches_full(
258 address: &str,
259 prefix: &str,
260 suffix: &str,
261 contains: &str,
262 ignore_case: bool,
263) -> bool {
264 matches_both(address, prefix, suffix, ignore_case)
265 && matches_contains(address, contains, ignore_case)
266}
267
268#[cfg(test)]
269mod tests {
270 use super::*;
271
272 #[test]
273 fn contains_and_wildcard() {
274 assert!(matches_contains("abcXYZdef", "XYZ", false));
275 assert!(matches_contains("abcXYZdef", "X*Z", false));
276 assert!(!matches_contains("abcXYZdef", "ZZZ", false));
277 assert!(matches_at("CoolEnd", "Cool*", false, true));
278 assert!(matches_at("xxpump", "*pump", false, false));
279 }
280}