Skip to main content

vanity_core/
pattern.rs

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    /// Literal character count used for difficulty estimates (`*` wildcards ignored).
48    pub fn effective_literal_chars(&self) -> usize {
49        literal_len(&self.prefix) + literal_len(&self.suffix) + literal_len(&self.contains)
50    }
51}
52
53/// One OR-alternative for build_pattern (prefix, suffix, contains).
54pub type PatternAlternative = (Option<String>, Option<String>, Option<String>);
55
56/// Split comma-separated OR alternatives. Only one of prefix/suffix/contains may
57/// contain commas; others are shared across all alternatives.
58pub 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
128/// Combined expected attempts when any of several patterns may match (OR).
129pub 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
174/// Glob-style match for a single `*` (zero or more chars) within an affix constraint.
175fn 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    // For prefix globs: must start with first literal; for suffix: must end with last.
197    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                // anchored start handled by caller for prefix; for contains, first part can be anywhere
223            }
224            rest = &rest[idx + part.len()..];
225        } else {
226            return false;
227        }
228    }
229    if !pattern.ends_with('*') {
230        // last literal already consumed from rest; ok
231    }
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}