,
37 | {
38 | let filter_map_entry = move |entry: DirEntry| {
39 | let file_type = entry.file_type().ok()?;
40 |
41 | if file_type.is_dir() || file_type.is_symlink() {
42 | let file_name: String = entry.file_name().into_string().ok()?;
43 |
44 | if let Some(congruence) = abbr.compare(&file_name) {
45 | let mut entry_congruence = parent_congruence.to_vec();
46 | entry_congruence.insert(0, congruence);
47 |
48 | return Some(Finding {
49 | file_name: entry.file_name(),
50 | congruence: entry_congruence,
51 | path: entry.path(),
52 | });
53 | }
54 | }
55 |
56 | None
57 | };
58 |
59 | path.as_ref()
60 | .read_dir()
61 | .ok()
62 | .map(|reader| {
63 | reader
64 | .filter_map(|entry| entry.ok())
65 | .filter_map(filter_map_entry)
66 | })
67 | .into_iter()
68 | .flatten()
69 | }
70 |
71 | /// The `query` subcommand.
72 | ///
73 | /// It takes two args — `--abbr` and `--exclude` (optionally). The value of
74 | /// `--abbr` gets split into a prefix containing components like `c:/`, `/`,
75 | /// `~/`, and dots, and [`Abbr`](Abbr)'s. If there is more than one dir matching
76 | /// the query, the value of `--exclude` is excluded from the search.
77 | pub fn query(arg: &P, excluded: Option) -> Result
78 | where
79 | P: AsRef,
80 | {
81 | // If the arg is a real path and not an abbreviation, return it. It
82 | // prevents potential unexpected behavior due to abbreviation expansion.
83 | // For example, `kn` doesn't allow for any component other than `Normal` in
84 | // the abbreviation but the arg itself may be a valid path. `kn` should only
85 | // behave differently from `cd` in situations where `cd` would fail.
86 | if arg.as_ref().is_dir() {
87 | return Ok(arg.as_ref().into());
88 | }
89 |
90 | let (prefix, abbrs) = parse_arg(&arg)?;
91 | let start_dir = match prefix {
92 | Some(start_dir) => start_dir,
93 | None => std::env::current_dir()?,
94 | };
95 |
96 | match abbrs.as_slice() {
97 | [] => Ok(start_dir),
98 | [first_abbr, abbrs @ ..] => {
99 | let mut current_level =
100 | get_matching_children(&start_dir, first_abbr, &[])
101 | .collect::>();
102 | let mut next_level = vec![];
103 |
104 | for abbr in abbrs {
105 | let children = current_level
106 | .iter()
107 | .map(|parent| {
108 | get_matching_children(
109 | &parent.path,
110 | abbr,
111 | &parent.congruence,
112 | )
113 | })
114 | .flatten();
115 |
116 | next_level.clear();
117 | next_level.extend(children);
118 |
119 | mem::swap(&mut next_level, &mut current_level);
120 | }
121 |
122 | let cmp_findings = |finding_a: &Finding, finding_b: &Finding| {
123 | finding_a.congruence.cmp(&finding_b.congruence).then(
124 | compare_os_str(&finding_a.file_name, &finding_b.file_name),
125 | )
126 | };
127 |
128 | let found_path = match excluded {
129 | Some(excluded) if current_level.len() > 1 => current_level
130 | .into_iter()
131 | .filter(|finding| finding.path != excluded)
132 | .min_by(cmp_findings)
133 | .map(|Finding { path, .. }| path),
134 | _ => current_level
135 | .into_iter()
136 | .min_by(cmp_findings)
137 | .map(|Finding { path, .. }| path),
138 | };
139 |
140 | found_path.ok_or(Error::PathNotFound)
141 | }
142 | }
143 | }
144 |
145 | /// Checks if the component contains only dots and returns the equivalent number
146 | /// of [`ParentDir`](Component::ParentDir) components if it does.
147 | ///
148 | /// It is the number of dots, less one. For example, `...` is converted to
149 | /// `../..`, `....` to `../../..` etc.
150 | fn parse_dots(component: &str) -> Option {
151 | component
152 | .chars()
153 | .try_fold(
154 | 0,
155 | |n_dots, c| if c == '.' { Some(n_dots + 1) } else { None },
156 | )
157 | .and_then(|n_dots| if n_dots > 1 { Some(n_dots - 1) } else { None })
158 | }
159 |
160 | /// Extracts leading components of the path that are not parts of the
161 | /// abbreviation.
162 | ///
163 | /// The prefix is the path where the search starts. If there is no prefix (when
164 | /// the path consists only of normal components), the search starts in the
165 | /// current directory, just as you'd expect. The function collects each
166 | /// [`Prefix`](Component::Prefix), [`RootDir`](Component::RootDir),
167 | /// [`CurDir`](Component::CurDir), and [`ParentDir`](Component::ParentDir)
168 | /// components and stops at the first [`Normal`](Component::Normal) component
169 | /// **unless** it only contains dots. In this case, it converts it to as many
170 | /// [`ParentDir`](Component::ParentDir)'s as there are dots in this component,
171 | /// less one. For example, `...` is converted to `../..`, `....` to `../../..`
172 | /// etc.
173 | fn extract_prefix<'a, P>(
174 | arg: &'a P,
175 | ) -> Result<(Option, impl Iterator- > + 'a), Error>
176 | where
177 | P: AsRef + ?Sized + 'a,
178 | {
179 | use Component::*;
180 |
181 | let mut components = arg.as_ref().components().peekable();
182 | let mut prefix: Option = None;
183 | let mut push_to_prefix = |component: Component| match &mut prefix {
184 | None => prefix = Some(PathBuf::from(&component)),
185 | Some(prefix) => prefix.push(component),
186 | };
187 | let parse_dots_os = |component_os: &OsStr| {
188 | component_os
189 | .to_os_string()
190 | .into_string()
191 | .map_err(|_| Error::NonUnicodeInput)
192 | .map(|component| parse_dots(&component))
193 | };
194 |
195 | while let Some(component) = components.peek() {
196 | match component {
197 | Prefix(_) | RootDir | CurDir | ParentDir =>
198 | push_to_prefix(*component),
199 | Normal(component_os) => {
200 | if let Some(n_dots) = parse_dots_os(component_os)? {
201 | (0..n_dots).for_each(|_| push_to_prefix(ParentDir));
202 | } else {
203 | break;
204 | }
205 | }
206 | }
207 |
208 | let _consumed = components.next();
209 | }
210 |
211 | Ok((prefix, components))
212 | }
213 |
214 | /// Converts each component into [`Abbr`](Abbr) without checking
215 | /// the component's type.
216 | ///
217 | /// This may change in the future.
218 | fn parse_abbrs<'a, I>(components: I) -> Result, Error>
219 | where
220 | I: Iterator
- > + 'a,
221 | {
222 | use Component::*;
223 |
224 | let abbrs = components
225 | .into_iter()
226 | .map(|component| match component {
227 | Prefix(_) | RootDir | CurDir | ParentDir => {
228 | let component_string = component
229 | .as_os_str()
230 | .to_os_string()
231 | .to_string_lossy()
232 | .to_string();
233 |
234 | Err(Error::UnexpectedAbbrComponent(component_string))
235 | }
236 | Normal(component_os) => component_os
237 | .to_os_string()
238 | .into_string()
239 | .map_err(|_| Error::NonUnicodeInput)
240 | .map(|string| Abbr::new_sanitized(&string)),
241 | })
242 | .collect::, _>>()?;
243 |
244 | Ok(abbrs)
245 | }
246 |
247 | /// Parses the provided argument into a prefix and [`Abbr`](Abbr)'s.
248 | fn parse_arg
(arg: &P) -> Result<(Option, Vec), Error>
249 | where
250 | P: AsRef,
251 | {
252 | let (prefix, suffix) = extract_prefix(arg)?;
253 | let abbrs = parse_abbrs(suffix)?;
254 |
255 | Ok((prefix, abbrs))
256 | }
257 |
258 | #[cfg(test)]
259 | mod test {
260 | use super::*;
261 |
262 | use crate::utils::as_path;
263 |
264 | #[test]
265 | fn test_parse_dots() {
266 | assert_variant!(parse_dots(""), None);
267 | assert_variant!(parse_dots("."), None);
268 | assert_variant!(parse_dots(".."), Some(1));
269 | assert_variant!(parse_dots("..."), Some(2));
270 | assert_variant!(parse_dots("...."), Some(3));
271 | assert_variant!(parse_dots("xyz"), None);
272 | assert_variant!(parse_dots("...dot"), None);
273 | }
274 |
275 | #[test]
276 | fn test_extract_prefix() {
277 | {
278 | let (prefix, suffix) = extract_prefix("suf/fix").unwrap();
279 | let suffix = suffix.collect::();
280 |
281 | assert_eq!(prefix, None);
282 | assert_eq!(as_path(&suffix), as_path("suf/fix"));
283 | }
284 |
285 | {
286 | let (prefix, suffix) = extract_prefix("./.././suf/fix").unwrap();
287 | let suffix = suffix.collect::();
288 |
289 | assert_eq!(prefix.unwrap(), as_path("./.."));
290 | assert_eq!(as_path(&suffix), as_path("suf/fix"));
291 | }
292 |
293 | {
294 | let (prefix, suffix) = extract_prefix(".../.../suf/fix").unwrap();
295 | let suffix = suffix.collect::();
296 |
297 | assert_eq!(prefix.unwrap(), as_path("../../../.."));
298 | assert_eq!(as_path(&suffix), as_path("suf/fix"));
299 | }
300 | }
301 |
302 | #[test]
303 | fn test_parse_arg_invalid_unicode() {
304 | #[cfg(unix)]
305 | {
306 | use std::ffi::OsStr;
307 | use std::os::unix::ffi::OsStrExt;
308 |
309 | let source = [0x66, 0x6f, 0x80, 0x6f];
310 | let non_unicode_input =
311 | OsStr::from_bytes(&source[..]).to_os_string();
312 | let result = parse_arg(&non_unicode_input);
313 |
314 | assert!(result.is_err());
315 | }
316 |
317 | #[cfg(windows)]
318 | {
319 | use std::os::windows::prelude::*;
320 |
321 | let source = [0x0066, 0x006f, 0xd800, 0x006f];
322 | let os_string = OsString::from_wide(&source[..]);
323 | let result = parse_arg(&non_unicode_input);
324 |
325 | assert!(result.is_err());
326 | }
327 | }
328 | }
329 |
--------------------------------------------------------------------------------
/src/utils.rs:
--------------------------------------------------------------------------------
1 | //! Utils.
2 |
3 | #[cfg(any(test, doc))]
4 | use std::{convert::AsRef, path::Path};
5 |
6 | /// Asserts that the expression matches the variant. Optionally returns a value.
7 | ///
8 | /// Inspired by [`std::matches`](https://doc.rust-lang.org/stable/std/macro.matches.html).
9 | ///
10 | /// # Examples
11 | ///
12 | /// ```
13 | /// # fn main() -> Option<()> {
14 | /// use kn::Congruence::*;
15 | ///
16 | /// let abbr = Abbr::new_sanitized("abcjkl");
17 | /// let coeff_1 = assert_variant!(abbr.compare("abc_jkl"), Some(Subsequence(coeff)) => coeff);
18 | /// let coeff_2 = assert_variant!(abbr.compare("ab_cj_kl"), Some(Subsequence(coeff)) => coeff);
19 | /// assert!(coeff_1 < coeff_2);
20 | /// # Ok(())
21 | /// # }
22 | /// ```
23 | #[cfg(any(test, doc))]
24 | #[macro_export]
25 | macro_rules! assert_variant {
26 | ($expression_in:expr , $( $pattern:pat )|+ $( if $guard: expr )? $( => $expression_out:expr )? ) => {
27 | match $expression_in {
28 | $( $pattern )|+ $( if $guard )? => { $( $expression_out )? },
29 | variant => panic!("{:?}", variant),
30 | }
31 | };
32 |
33 |
34 | ($expression_in:expr , $( $pattern:pat )|+ $( if $guard: expr )? $( => $expression_out:expr)? , $panic:expr) => {
35 | match $expression_in {
36 | $( $pattern )|+ $( if $guard )? => { $( $expression_out )? },
37 | _ => panic!($panic),
38 | }
39 | };
40 | }
41 |
42 | /// Shorthand for `AsRef::as_ref(&x)`.
43 | #[cfg(any(test, doc))]
44 | pub fn as_path(path: &P) -> &Path
45 | where
46 | P: AsRef + ?Sized,
47 | {
48 | path.as_ref()
49 | }
50 |
--------------------------------------------------------------------------------
8 |