git.iko.soy/helix
on master help sign in
add substring matching options to picker (#5114)
f0c2e89Pascal Kuthe
helix-term/src/ui/fuzzy_match.rs+201−36
compare with master
unifiedsplit
@@ -4,41 +4,209 @@ use fuzzy_matcher::FuzzyMatcher;
4#[cfg(test)]
4#[cfg(test)]
5mod test;
5mod test;
6
6
7+struct QueryAtom {
8+ kind: QueryAtomKind,
9+ atom: String,
10+ ignore_case: bool,
11+ inverse: bool,
12+}
13+impl QueryAtom {
14+ fn new(atom: &str) -> Option<QueryAtom> {
15+ let mut atom = atom.to_string();
16+ let inverse = atom.starts_with('!');
17+ if inverse {
18+ atom.remove(0);
19+ }
20+
21+ let mut kind = match atom.chars().next() {
22+ Some('^') => QueryAtomKind::Prefix,
23+ Some('\'') => QueryAtomKind::Substring,
24+ _ if inverse => QueryAtomKind::Substring,
25+ _ => QueryAtomKind::Fuzzy,
26+ };
27+
28+ if atom.starts_with(&['^', '\'']) {
29+ atom.remove(0);
30+ }
31+
32+ if atom.is_empty() {
33+ return None;
34+ }
35+
36+ if atom.ends_with('$') && !atom.ends_with("\\$") {
37+ atom.pop();
38+ kind = if kind == QueryAtomKind::Prefix {
39+ QueryAtomKind::Exact
40+ } else {
41+ QueryAtomKind::Postfix
42+ }
43+ }
44+
45+ Some(QueryAtom {
46+ kind,
47+ atom: atom.replace('\\', ""),
48+ // not ideal but fuzzy_matches only knows ascii uppercase so more consistent
49+ // to behave the same
50+ ignore_case: kind != QueryAtomKind::Fuzzy
51+ && atom.chars().all(|c| c.is_ascii_lowercase()),
52+ inverse,
53+ })
54+ }
55+
56+ fn indices(&self, matcher: &Matcher, item: &str, indices: &mut Vec<usize>) -> bool {
57+ // for inverse there are no indicies to return
58+ // just return whether we matched
59+ if self.inverse {
60+ return self.matches(matcher, item);
61+ }
62+ let buf;
63+ let item = if self.ignore_case {
64+ buf = item.to_ascii_lowercase();
65+ &buf
66+ } else {
67+ item
68+ };
69+ let off = match self.kind {
70+ QueryAtomKind::Fuzzy => {
71+ if let Some((_, fuzzy_indices)) = matcher.fuzzy_indices(item, &self.atom) {
72+ indices.extend_from_slice(&fuzzy_indices);
73+ return true;
74+ } else {
75+ return false;
76+ }
77+ }
78+ QueryAtomKind::Substring => {
79+ if let Some(off) = item.find(&self.atom) {
80+ off
81+ } else {
82+ return false;
83+ }
84+ }
85+ QueryAtomKind::Prefix if item.starts_with(&self.atom) => 0,
86+ QueryAtomKind::Postfix if item.ends_with(&self.atom) => item.len() - self.atom.len(),
87+ QueryAtomKind::Exact if item == self.atom => 0,
88+ _ => return false,
89+ };
90+
91+ indices.extend(off..(off + self.atom.len()));
92+ true
93+ }
94+
95+ fn matches(&self, matcher: &Matcher, item: &str) -> bool {
96+ let buf;
97+ let item = if self.ignore_case {
98+ buf = item.to_ascii_lowercase();
99+ &buf
100+ } else {
101+ item
102+ };
103+ let mut res = match self.kind {
104+ QueryAtomKind::Fuzzy => matcher.fuzzy_match(item, &self.atom).is_some(),
105+ QueryAtomKind::Substring => item.contains(&self.atom),
106+ QueryAtomKind::Prefix => item.starts_with(&self.atom),
107+ QueryAtomKind::Postfix => item.ends_with(&self.atom),
108+ QueryAtomKind::Exact => item == self.atom,
109+ };
110+ if self.inverse {
111+ res = !res;
112+ }
113+ res
114+ }
115+}
116+
117+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
118+enum QueryAtomKind {
119+ /// Item is a fuzzy match of this behaviour
120+ ///
121+ /// Usage: `foo`
122+ Fuzzy,
123+ /// Item contains query atom as a continous substring
124+ ///
125+ /// Usage `'foo`
126+ Substring,
127+ /// Item starts with query atom
128+ ///
129+ /// Usage: `^foo`
130+ Prefix,
131+ /// Item ends with query atom
132+ ///
133+ /// Usage: `foo$`
134+ Postfix,
135+ /// Item is equal to query atom
136+ ///
137+ /// Usage `^foo$`
138+ Exact,
139+}
140+
141+#[derive(Default)]
7pub struct FuzzyQuery {
142pub struct FuzzyQuery {
8− queries: Vec<String>,
143+ first_fuzzy_atom: Option<String>,
144+ query_atoms: Vec<QueryAtom>,
145+}
146+
147+fn query_atoms(query: &str) -> impl Iterator<Item = &str> + '_ {
148+ let mut saw_backslash = false;
149+ query.split(move |c| {
150+ saw_backslash = match c {
151+ ' ' if !saw_backslash => return true,
152+ '\\' => true,
153+ _ => false,
154+ };
155+ false
156+ })
9}
157}
10
158
11impl FuzzyQuery {
159impl FuzzyQuery {
160+ pub fn refine(&self, query: &str, old_query: &str) -> (FuzzyQuery, bool) {
161+ // TODO: we could be a lot smarter about this
162+ let new_query = Self::new(query);
163+ let mut is_refinement = query.starts_with(old_query);
164+
165+ // if the last atom is an inverse atom adding more text to it
166+ // will actually increase the number of matches and we can not refine
167+ // the matches.
168+ if is_refinement && !self.query_atoms.is_empty() {
169+ let last_idx = self.query_atoms.len() - 1;
170+ if self.query_atoms[last_idx].inverse
171+ && self.query_atoms[last_idx].atom != new_query.query_atoms[last_idx].atom
172+ {
173+ is_refinement = false;
174+ }
175+ }
176+
177+ (new_query, is_refinement)
178+ }
179+
12 pub fn new(query: &str) -> FuzzyQuery {
180 pub fn new(query: &str) -> FuzzyQuery {
13− let mut saw_backslash = false;
181+ let mut first_fuzzy_query = None;
14− let queries = query
182+ let query_atoms = query_atoms(query)
15− .split(|c| {
16− saw_backslash = match c {
17− ' ' if !saw_backslash => return true,
18− '\\' => true,
19− _ => false,
20− };
21− false
22− })
23− .filter_map(|query| {
183+ .filter_map(|atom| {
24− if query.is_empty() {
184+ let atom = QueryAtom::new(atom)?;
185+ if atom.kind == QueryAtomKind::Fuzzy && first_fuzzy_query.is_none() {
186+ first_fuzzy_query = Some(atom.atom);
25 None
187 None
26 } else {
188 } else {
27− Some(query.replace("\\ ", " "))
189+ Some(atom)
28 }
190 }
29 })
191 })
30 .collect();
192 .collect();
31− FuzzyQuery { queries }
193+ FuzzyQuery {
194+ first_fuzzy_atom: first_fuzzy_query,
195+ query_atoms,
196+ }
32 }
197 }
33
198
34 pub fn fuzzy_match(&self, item: &str, matcher: &Matcher) -> Option<i64> {
199 pub fn fuzzy_match(&self, item: &str, matcher: &Matcher) -> Option<i64> {
35− // use the rank of the first query for the rank, because merging ranks is not really possible
200+ // use the rank of the first fuzzzy query for the rank, because merging ranks is not really possible
36 // this behaviour matches fzf and skim
201 // this behaviour matches fzf and skim
202+ let score = self
203+ .first_fuzzy_atom
204+ .as_ref()
37− let score = matcher.fuzzy_match(item, self.queries.get(0)?)?;
205+ .map_or(Some(0), |atom| matcher.fuzzy_match(item, atom))?;
38 if self
206 if self
39− .queries
207+ .query_atoms
40 .iter()
208 .iter()
41− .any(|query| matcher.fuzzy_match(item, query).is_none())
209+ .any(|atom| !atom.matches(matcher, item))
42 {
210 {
43 return None;
211 return None;
44 }
212 }
@@ -46,29 +214,26 @@ impl FuzzyQuery {
46 }
214 }
47
215
48 pub fn fuzzy_indicies(&self, item: &str, matcher: &Matcher) -> Option<(i64, Vec<usize>)> {
216 pub fn fuzzy_indicies(&self, item: &str, matcher: &Matcher) -> Option<(i64, Vec<usize>)> {
49− if self.queries.len() == 1 {
217+ let (score, mut indices) = self.first_fuzzy_atom.as_ref().map_or_else(
50− return matcher.fuzzy_indices(item, &self.queries[0]);
218+ || Some((0, Vec::new())),
51− }
52−
53− // use the rank of the first query for the rank, because merging ranks is not really possible
54− // this behaviour matches fzf and skim
55− let (score, mut indicies) = matcher.fuzzy_indices(item, self.queries.get(0)?)?;
219+ |atom| matcher.fuzzy_indices(item, atom),
220+ )?;
56
221
57− // fast path for the common case of not using a space
222+ // fast path for the common case of just a single atom
58− // during matching this branch should be free thanks to branch prediction
223+ if self.query_atoms.is_empty() {
59− if self.queries.len() == 1 {
60− return Some((score, indicies));
224+ return Some((score, indices));
61 }
225 }
62
226
63− for query in &self.queries[1..] {
227+ for atom in &self.query_atoms {
64− let (_, matched_indicies) = matcher.fuzzy_indices(item, query)?;
228+ if !atom.indices(matcher, item, &mut indices) {
65− indicies.extend_from_slice(&matched_indicies);
229+ return None;
230+ }
66 }
231 }
67
232
68 // deadup and remove duplicate matches
233 // deadup and remove duplicate matches
69− indicies.sort_unstable();
234+ indices.sort_unstable();
70− indicies.dedup();
235+ indices.dedup();
71
236
72− Some((score, indicies))
237+ Some((score, indices))
73 }
238 }
74}
239}
helix-term/src/ui/picker.rs+11−6
@@ -407,7 +407,7 @@ pub struct Picker<T: Item> {
407 cursor: usize,
407 cursor: usize,
408 // pattern: String,
408 // pattern: String,
409 prompt: Prompt,
409 prompt: Prompt,
410− previous_pattern: String,
410+ previous_pattern: (String, FuzzyQuery),
411 /// Whether to truncate the start (default true)
411 /// Whether to truncate the start (default true)
412 pub truncate_start: bool,
412 pub truncate_start: bool,
413 /// Whether to show the preview panel (default true)
413 /// Whether to show the preview panel (default true)
@@ -458,7 +458,7 @@ impl<T: Item> Picker<T> {
458 matches: Vec::new(),
458 matches: Vec::new(),
459 cursor: 0,
459 cursor: 0,
460 prompt,
460 prompt,
461− previous_pattern: String::new(),
461+ previous_pattern: (String::new(), FuzzyQuery::default()),
462 truncate_start: true,
462 truncate_start: true,
463 show_preview: true,
463 show_preview: true,
464 callback_fn: Box::new(callback_fn),
464 callback_fn: Box::new(callback_fn),
@@ -485,10 +485,15 @@ impl<T: Item> Picker<T> {
485 pub fn score(&mut self) {
485 pub fn score(&mut self) {
486 let pattern = self.prompt.line();
486 let pattern = self.prompt.line();
487
487
488− if pattern == &self.previous_pattern {
488+ if pattern == &self.previous_pattern.0 {
489 return;
489 return;
490 }
490 }
491
491
492+ let (query, is_refined) = self
493+ .previous_pattern
494+ .1
495+ .refine(pattern, &self.previous_pattern.0);
496+
492 if pattern.is_empty() {
497 if pattern.is_empty() {
493 // Fast path for no pattern.
498 // Fast path for no pattern.
494 self.matches.clear();
499 self.matches.clear();
@@ -501,8 +506,7 @@ impl<T: Item> Picker<T> {
501 len: text.chars().count(),
506 len: text.chars().count(),
502 }
507 }
503 }));
508 }));
504− } else if pattern.starts_with(&self.previous_pattern) {
509+ } else if is_refined {
505− let query = FuzzyQuery::new(pattern);
506 // optimization: if the pattern is a more specific version of the previous one
510 // optimization: if the pattern is a more specific version of the previous one
507 // then we can score the filtered set.
511 // then we can score the filtered set.
508 self.matches.retain_mut(|pmatch| {
512 self.matches.retain_mut(|pmatch| {
@@ -527,7 +531,8 @@ impl<T: Item> Picker<T> {
527 // reset cursor position
531 // reset cursor position
528 self.cursor = 0;
532 self.cursor = 0;
529 let pattern = self.prompt.line();
533 let pattern = self.prompt.line();
530− self.previous_pattern.clone_from(pattern);
534+ self.previous_pattern.0.clone_from(pattern);
535+ self.previous_pattern.1 = query;
531 }
536 }
532
537
533 pub fn force_score(&mut self) {
538 pub fn force_score(&mut self) {