1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
//! a pattern for filtering and sorting filenames.
//! It's backed either by a fuzzy pattern matcher or
//! by a regular expression (in which case there's no real
//! score)
use core::result;
use std::{fmt, mem};
use crate::errors::RegexError;
use crate::fuzzy_patterns::FuzzyPattern;
use crate::regex_patterns::RegexPattern;
#[derive(Debug, Clone)]
pub enum Pattern {
None,
Fuzzy(FuzzyPattern),
Regex(RegexPattern),
}
impl fmt::Display for Pattern {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Pattern::Fuzzy(fp) => write!(f, "Fuzzy({})", fp),
Pattern::Regex(rp) => write!(f, "Regex({})", rp),
Pattern::None => write!(f, "None"),
}
}
}
impl Pattern {
/// create a new fuzzy pattern
pub fn fuzzy(pat: &str) -> Pattern {
Pattern::Fuzzy(FuzzyPattern::from(pat))
}
/// try to create a regex pattern
pub fn regex(pat: &str, flags: &str) -> result::Result<Pattern, RegexError> {
Ok(Pattern::Regex(RegexPattern::from(pat, flags)?))
}
pub fn find(&self, candidate: &str) -> Option<Match> {
match self {
Pattern::Fuzzy(fp) => fp.find(candidate),
Pattern::Regex(rp) => rp.find(candidate),
Pattern::None => Some(Match {
// this isn't really supposed to be used
score: 1,
pos: Vec::with_capacity(0),
}),
}
}
pub fn is_some(&self) -> bool {
match self {
Pattern::None => false,
_ => true,
}
}
/// empties the pattern and return it
/// Similar to Option::take
pub fn take(&mut self) -> Pattern {
mem::replace(self, Pattern::None)
}
// return the number of results we should find before starting to
// sort them (unless time is runing out).
pub fn optimal_result_number(&self, targeted_size: usize) -> usize {
match self {
Pattern::Fuzzy(fp) => fp.optimal_result_number(targeted_size),
Pattern::Regex(rp) => rp.optimal_result_number(targeted_size),
Pattern::None => targeted_size,
}
}
}
/// A Match is a positive result of pattern matching
#[derive(Debug)]
pub struct Match {
pub score: i32, // score of the match, guaranteed strictly positive, bigger is better
pub pos: Vec<usize>, // positions of the matching chars
}
impl Match {
// returns a new string made from candidate (which should be at the origin of the match)
// where the characters at positions pos (matching chars) are wrapped between
// prefix and postfix
pub fn wrap_matching_chars(&self, candidate: &str, prefix: &str, postfix: &str) -> String {
let mut pos_idx: usize = 0;
let mut decorated = String::new();
for (cand_idx, cand_char) in candidate.chars().enumerate() {
if pos_idx < self.pos.len() && self.pos[pos_idx] == cand_idx {
decorated.push_str(prefix);
decorated.push(cand_char);
decorated.push_str(postfix);
pos_idx += 1;
} else {
decorated.push(cand_char);
}
}
decorated
}
}
|
