1use globset::{Glob, GlobSet, GlobSetBuilder};
2use itertools::Itertools;
3use regex::Regex;
4use serde::{Deserialize, Serialize};
5use std::cmp::Ordering;
6use std::fmt::{Display, Formatter};
7use std::mem;
8use std::path::StripPrefixError;
9use std::sync::{Arc, OnceLock};
10use std::{
11 ffi::OsStr,
12 path::{Path, PathBuf},
13 sync::LazyLock,
14};
15
16use crate::rel_path::RelPath;
17
18static HOME_DIR: OnceLock<PathBuf> = OnceLock::new();
19
20/// Returns the path to the user's home directory.
21pub fn home_dir() -> &'static PathBuf {
22 HOME_DIR.get_or_init(|| {
23 if cfg!(any(test, feature = "test-support")) {
24 if cfg!(target_os = "macos") {
25 PathBuf::from("/Users/zed")
26 } else if cfg!(target_os = "windows") {
27 PathBuf::from("C:\\Users\\zed")
28 } else {
29 PathBuf::from("/home/zed")
30 }
31 } else {
32 dirs::home_dir().expect("failed to determine home directory")
33 }
34 })
35}
36
37pub trait PathExt {
38 fn compact(&self) -> PathBuf;
39 fn extension_or_hidden_file_name(&self) -> Option<&str>;
40 fn try_from_bytes<'a>(bytes: &'a [u8]) -> anyhow::Result<Self>
41 where
42 Self: From<&'a Path>,
43 {
44 #[cfg(unix)]
45 {
46 use std::os::unix::prelude::OsStrExt;
47 Ok(Self::from(Path::new(OsStr::from_bytes(bytes))))
48 }
49 #[cfg(windows)]
50 {
51 use anyhow::Context as _;
52 use tendril::fmt::{Format, WTF8};
53 WTF8::validate(bytes)
54 .then(|| {
55 // Safety: bytes are valid WTF-8 sequence.
56 Self::from(Path::new(unsafe {
57 OsStr::from_encoded_bytes_unchecked(bytes)
58 }))
59 })
60 .with_context(|| format!("Invalid WTF-8 sequence: {bytes:?}"))
61 }
62 }
63 fn local_to_wsl(&self) -> Option<PathBuf>;
64 fn multiple_extensions(&self) -> Option<String>;
65}
66
67impl<T: AsRef<Path>> PathExt for T {
68 /// Compacts a given file path by replacing the user's home directory
69 /// prefix with a tilde (`~`).
70 ///
71 /// # Returns
72 ///
73 /// * A `PathBuf` containing the compacted file path. If the input path
74 /// does not have the user's home directory prefix, or if we are not on
75 /// Linux or macOS, the original path is returned unchanged.
76 fn compact(&self) -> PathBuf {
77 if cfg!(any(target_os = "linux", target_os = "freebsd")) || cfg!(target_os = "macos") {
78 match self.as_ref().strip_prefix(home_dir().as_path()) {
79 Ok(relative_path) => {
80 let mut shortened_path = PathBuf::new();
81 shortened_path.push("~");
82 shortened_path.push(relative_path);
83 shortened_path
84 }
85 Err(_) => self.as_ref().to_path_buf(),
86 }
87 } else {
88 self.as_ref().to_path_buf()
89 }
90 }
91
92 /// Returns a file's extension or, if the file is hidden, its name without the leading dot
93 fn extension_or_hidden_file_name(&self) -> Option<&str> {
94 let path = self.as_ref();
95 let file_name = path.file_name()?.to_str()?;
96 if file_name.starts_with('.') {
97 return file_name.strip_prefix('.');
98 }
99
100 path.extension()
101 .and_then(|e| e.to_str())
102 .or_else(|| path.file_stem()?.to_str())
103 }
104
105 /// Converts a local path to one that can be used inside of WSL.
106 /// Returns `None` if the path cannot be converted into a WSL one (network share).
107 fn local_to_wsl(&self) -> Option<PathBuf> {
108 // quite sketchy to convert this back to path at the end, but a lot of functions only accept paths
109 // todo: ideally rework them..?
110 let mut new_path = std::ffi::OsString::new();
111 for component in self.as_ref().components() {
112 match component {
113 std::path::Component::Prefix(prefix) => {
114 let drive_letter = prefix.as_os_str().to_string_lossy().to_lowercase();
115 let drive_letter = drive_letter.strip_suffix(':')?;
116
117 new_path.push(format!("/mnt/{}", drive_letter));
118 }
119 std::path::Component::RootDir => {}
120 std::path::Component::CurDir => {
121 new_path.push("/.");
122 }
123 std::path::Component::ParentDir => {
124 new_path.push("/..");
125 }
126 std::path::Component::Normal(os_str) => {
127 new_path.push("/");
128 new_path.push(os_str);
129 }
130 }
131 }
132
133 Some(new_path.into())
134 }
135
136 /// Returns a file's "full" joined collection of extensions, in the case where a file does not
137 /// just have a singular extension but instead has multiple (e.g File.tar.gz, Component.stories.tsx)
138 ///
139 /// Will provide back the extensions joined together such as tar.gz or stories.tsx
140 fn multiple_extensions(&self) -> Option<String> {
141 let path = self.as_ref();
142 let file_name = path.file_name()?.to_str()?;
143
144 let parts: Vec<&str> = file_name
145 .split('.')
146 // Skip the part with the file name extension
147 .skip(1)
148 .collect();
149
150 if parts.len() < 2 {
151 return None;
152 }
153
154 Some(parts.into_iter().join("."))
155 }
156}
157
158/// In memory, this is identical to `Path`. On non-Windows conversions to this type are no-ops. On
159/// windows, these conversions sanitize UNC paths by removing the `\\\\?\\` prefix.
160#[derive(Eq, PartialEq, Hash, Ord, PartialOrd)]
161#[repr(transparent)]
162pub struct SanitizedPath(Path);
163
164impl SanitizedPath {
165 pub fn new<T: AsRef<Path> + ?Sized>(path: &T) -> &Self {
166 #[cfg(not(target_os = "windows"))]
167 return Self::unchecked_new(path.as_ref());
168
169 #[cfg(target_os = "windows")]
170 return Self::unchecked_new(dunce::simplified(path.as_ref()));
171 }
172
173 pub fn unchecked_new<T: AsRef<Path> + ?Sized>(path: &T) -> &Self {
174 // safe because `Path` and `SanitizedPath` have the same repr and Drop impl
175 unsafe { mem::transmute::<&Path, &Self>(path.as_ref()) }
176 }
177
178 pub fn from_arc(path: Arc<Path>) -> Arc<Self> {
179 // safe because `Path` and `SanitizedPath` have the same repr and Drop impl
180 #[cfg(not(target_os = "windows"))]
181 return unsafe { mem::transmute::<Arc<Path>, Arc<Self>>(path) };
182
183 // TODO: could avoid allocating here if dunce::simplified results in the same path
184 #[cfg(target_os = "windows")]
185 return Self::new(&path).into();
186 }
187
188 pub fn new_arc<T: AsRef<Path> + ?Sized>(path: &T) -> Arc<Self> {
189 Self::new(path).into()
190 }
191
192 pub fn cast_arc(path: Arc<Self>) -> Arc<Path> {
193 // safe because `Path` and `SanitizedPath` have the same repr and Drop impl
194 unsafe { mem::transmute::<Arc<Self>, Arc<Path>>(path) }
195 }
196
197 pub fn cast_arc_ref(path: &Arc<Self>) -> &Arc<Path> {
198 // safe because `Path` and `SanitizedPath` have the same repr and Drop impl
199 unsafe { mem::transmute::<&Arc<Self>, &Arc<Path>>(path) }
200 }
201
202 pub fn starts_with(&self, prefix: &Self) -> bool {
203 self.0.starts_with(&prefix.0)
204 }
205
206 pub fn as_path(&self) -> &Path {
207 &self.0
208 }
209
210 pub fn file_name(&self) -> Option<&std::ffi::OsStr> {
211 self.0.file_name()
212 }
213
214 pub fn extension(&self) -> Option<&std::ffi::OsStr> {
215 self.0.extension()
216 }
217
218 pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf {
219 self.0.join(path)
220 }
221
222 pub fn parent(&self) -> Option<&Self> {
223 self.0.parent().map(Self::unchecked_new)
224 }
225
226 pub fn strip_prefix(&self, base: &Self) -> Result<&Path, StripPrefixError> {
227 self.0.strip_prefix(base.as_path())
228 }
229
230 pub fn to_str(&self) -> Option<&str> {
231 self.0.to_str()
232 }
233
234 pub fn to_path_buf(&self) -> PathBuf {
235 self.0.to_path_buf()
236 }
237}
238
239impl std::fmt::Debug for SanitizedPath {
240 fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
241 std::fmt::Debug::fmt(&self.0, formatter)
242 }
243}
244
245impl Display for SanitizedPath {
246 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
247 write!(f, "{}", self.0.display())
248 }
249}
250
251impl From<&SanitizedPath> for Arc<SanitizedPath> {
252 fn from(sanitized_path: &SanitizedPath) -> Self {
253 let path: Arc<Path> = sanitized_path.0.into();
254 // safe because `Path` and `SanitizedPath` have the same repr and Drop impl
255 unsafe { mem::transmute(path) }
256 }
257}
258
259impl From<&SanitizedPath> for PathBuf {
260 fn from(sanitized_path: &SanitizedPath) -> Self {
261 sanitized_path.as_path().into()
262 }
263}
264
265impl AsRef<Path> for SanitizedPath {
266 fn as_ref(&self) -> &Path {
267 &self.0
268 }
269}
270
271#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
272pub enum PathStyle {
273 Posix,
274 Windows,
275}
276
277impl PathStyle {
278 #[cfg(target_os = "windows")]
279 pub const fn local() -> Self {
280 PathStyle::Windows
281 }
282
283 #[cfg(not(target_os = "windows"))]
284 pub const fn local() -> Self {
285 PathStyle::Posix
286 }
287
288 #[inline]
289 pub fn separator(&self) -> &'static str {
290 match self {
291 PathStyle::Posix => "/",
292 PathStyle::Windows => "\\",
293 }
294 }
295
296 pub fn is_windows(&self) -> bool {
297 *self == PathStyle::Windows
298 }
299
300 pub fn join(self, left: impl AsRef<Path>, right: impl AsRef<Path>) -> Option<String> {
301 let right = right.as_ref().to_str()?;
302 if is_absolute(right, self) {
303 return None;
304 }
305 let left = left.as_ref().to_str()?;
306 if left.is_empty() {
307 Some(right.into())
308 } else {
309 Some(format!(
310 "{left}{}{right}",
311 if left.ends_with(self.separator()) {
312 ""
313 } else {
314 self.separator()
315 }
316 ))
317 }
318 }
319
320 pub fn split(self, path_like: &str) -> (Option<&str>, &str) {
321 let Some(pos) = path_like.rfind(self.separator()) else {
322 return (None, path_like);
323 };
324 let filename_start = pos + self.separator().len();
325 (
326 Some(&path_like[..filename_start]),
327 &path_like[filename_start..],
328 )
329 }
330}
331
332#[derive(Debug, Clone)]
333pub struct RemotePathBuf {
334 style: PathStyle,
335 string: String,
336}
337
338impl RemotePathBuf {
339 pub fn new(string: String, style: PathStyle) -> Self {
340 Self { style, string }
341 }
342
343 pub fn from_str(path: &str, style: PathStyle) -> Self {
344 Self::new(path.to_string(), style)
345 }
346
347 pub fn path_style(&self) -> PathStyle {
348 self.style
349 }
350
351 pub fn to_proto(self) -> String {
352 self.string
353 }
354}
355
356impl Display for RemotePathBuf {
357 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
358 write!(f, "{}", self.string)
359 }
360}
361
362pub fn is_absolute(path_like: &str, path_style: PathStyle) -> bool {
363 path_like.starts_with('/')
364 || path_style == PathStyle::Windows
365 && (path_like.starts_with('\\')
366 || path_like
367 .chars()
368 .next()
369 .is_some_and(|c| c.is_ascii_alphabetic())
370 && path_like[1..]
371 .strip_prefix(':')
372 .is_some_and(|path| path.starts_with('/') || path.starts_with('\\')))
373}
374
375/// A delimiter to use in `path_query:row_number:column_number` strings parsing.
376pub const FILE_ROW_COLUMN_DELIMITER: char = ':';
377
378const ROW_COL_CAPTURE_REGEX: &str = r"(?xs)
379 ([^\(]+)\:(?:
380 \((\d+)[,:](\d+)\) # filename:(row,column), filename:(row:column)
381 |
382 \((\d+)\)() # filename:(row)
383 )
384 |
385 ([^\(]+)(?:
386 \((\d+)[,:](\d+)\) # filename(row,column), filename(row:column)
387 |
388 \((\d+)\)() # filename(row)
389 )
390 |
391 (.+?)(?:
392 \:+(\d+)\:(\d+)\:*$ # filename:row:column
393 |
394 \:+(\d+)\:*()$ # filename:row
395 |
396 \:+()()$
397 )";
398
399/// A representation of a path-like string with optional row and column numbers.
400/// Matching values example: `te`, `test.rs:22`, `te:22:5`, `test.c(22)`, `test.c(22,5)`etc.
401#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
402pub struct PathWithPosition {
403 pub path: PathBuf,
404 pub row: Option<u32>,
405 // Absent if row is absent.
406 pub column: Option<u32>,
407}
408
409impl PathWithPosition {
410 /// Returns a PathWithPosition from a path.
411 pub fn from_path(path: PathBuf) -> Self {
412 Self {
413 path,
414 row: None,
415 column: None,
416 }
417 }
418
419 /// Parses a string that possibly has `:row:column` or `(row, column)` suffix.
420 /// Parenthesis format is used by [MSBuild](https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-diagnostic-format-for-tasks) compatible tools
421 /// Ignores trailing `:`s, so `test.rs:22:` is parsed as `test.rs:22`.
422 /// If the suffix parsing fails, the whole string is parsed as a path.
423 ///
424 /// Be mindful that `test_file:10:1:` is a valid posix filename.
425 /// `PathWithPosition` class assumes that the ending position-like suffix is **not** part of the filename.
426 ///
427 /// # Examples
428 ///
429 /// ```
430 /// # use zed_util::paths::PathWithPosition;
431 /// # use std::path::PathBuf;
432 /// assert_eq!(PathWithPosition::parse_str("test_file"), PathWithPosition {
433 /// path: PathBuf::from("test_file"),
434 /// row: None,
435 /// column: None,
436 /// });
437 /// assert_eq!(PathWithPosition::parse_str("test_file:10"), PathWithPosition {
438 /// path: PathBuf::from("test_file"),
439 /// row: Some(10),
440 /// column: None,
441 /// });
442 /// assert_eq!(PathWithPosition::parse_str("test_file.rs"), PathWithPosition {
443 /// path: PathBuf::from("test_file.rs"),
444 /// row: None,
445 /// column: None,
446 /// });
447 /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1"), PathWithPosition {
448 /// path: PathBuf::from("test_file.rs"),
449 /// row: Some(1),
450 /// column: None,
451 /// });
452 /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1:2"), PathWithPosition {
453 /// path: PathBuf::from("test_file.rs"),
454 /// row: Some(1),
455 /// column: Some(2),
456 /// });
457 /// ```
458 ///
459 /// # Expected parsing results when encounter ill-formatted inputs.
460 /// ```
461 /// # use zed_util::paths::PathWithPosition;
462 /// # use std::path::PathBuf;
463 /// assert_eq!(PathWithPosition::parse_str("test_file.rs:a"), PathWithPosition {
464 /// path: PathBuf::from("test_file.rs:a"),
465 /// row: None,
466 /// column: None,
467 /// });
468 /// assert_eq!(PathWithPosition::parse_str("test_file.rs:a:b"), PathWithPosition {
469 /// path: PathBuf::from("test_file.rs:a:b"),
470 /// row: None,
471 /// column: None,
472 /// });
473 /// assert_eq!(PathWithPosition::parse_str("test_file.rs"), PathWithPosition {
474 /// path: PathBuf::from("test_file.rs"),
475 /// row: None,
476 /// column: None,
477 /// });
478 /// assert_eq!(PathWithPosition::parse_str("test_file.rs::1"), PathWithPosition {
479 /// path: PathBuf::from("test_file.rs"),
480 /// row: Some(1),
481 /// column: None,
482 /// });
483 /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1::"), PathWithPosition {
484 /// path: PathBuf::from("test_file.rs"),
485 /// row: Some(1),
486 /// column: None,
487 /// });
488 /// assert_eq!(PathWithPosition::parse_str("test_file.rs::1:2"), PathWithPosition {
489 /// path: PathBuf::from("test_file.rs"),
490 /// row: Some(1),
491 /// column: Some(2),
492 /// });
493 /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1::2"), PathWithPosition {
494 /// path: PathBuf::from("test_file.rs:1"),
495 /// row: Some(2),
496 /// column: None,
497 /// });
498 /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1:2:3"), PathWithPosition {
499 /// path: PathBuf::from("test_file.rs:1"),
500 /// row: Some(2),
501 /// column: Some(3),
502 /// });
503 /// ```
504 pub fn parse_str(s: &str) -> Self {
505 let trimmed = s.trim();
506 let path = Path::new(trimmed);
507 let maybe_file_name_with_row_col = path.file_name().unwrap_or_default().to_string_lossy();
508 if maybe_file_name_with_row_col.is_empty() {
509 return Self {
510 path: Path::new(s).to_path_buf(),
511 row: None,
512 column: None,
513 };
514 }
515
516 // Let's avoid repeated init cost on this. It is subject to thread contention, but
517 // so far this code isn't called from multiple hot paths. Getting contention here
518 // in the future seems unlikely.
519 static SUFFIX_RE: LazyLock<Regex> =
520 LazyLock::new(|| Regex::new(ROW_COL_CAPTURE_REGEX).unwrap());
521 match SUFFIX_RE
522 .captures(&maybe_file_name_with_row_col)
523 .map(|caps| caps.extract())
524 {
525 Some((_, [file_name, maybe_row, maybe_column])) => {
526 let row = maybe_row.parse::<u32>().ok();
527 let column = maybe_column.parse::<u32>().ok();
528
529 let suffix_length = maybe_file_name_with_row_col.len() - file_name.len();
530 let path_without_suffix = &trimmed[..trimmed.len() - suffix_length];
531
532 Self {
533 path: Path::new(path_without_suffix).to_path_buf(),
534 row,
535 column,
536 }
537 }
538 None => {
539 // The `ROW_COL_CAPTURE_REGEX` deals with separated digits only,
540 // but in reality there could be `foo/bar.py:22:in` inputs which we want to match too.
541 // The regex mentioned is not very extendable with "digit or random string" checks, so do this here instead.
542 let delimiter = ':';
543 let mut path_parts = s
544 .rsplitn(3, delimiter)
545 .collect::<Vec<_>>()
546 .into_iter()
547 .rev()
548 .fuse();
549 let mut path_string = path_parts.next().expect("rsplitn should have the rest of the string as its last parameter that we reversed").to_owned();
550 let mut row = None;
551 let mut column = None;
552 if let Some(maybe_row) = path_parts.next() {
553 if let Ok(parsed_row) = maybe_row.parse::<u32>() {
554 row = Some(parsed_row);
555 if let Some(parsed_column) = path_parts
556 .next()
557 .and_then(|maybe_col| maybe_col.parse::<u32>().ok())
558 {
559 column = Some(parsed_column);
560 }
561 } else {
562 path_string.push(delimiter);
563 path_string.push_str(maybe_row);
564 }
565 }
566 for split in path_parts {
567 path_string.push(delimiter);
568 path_string.push_str(split);
569 }
570
571 Self {
572 path: PathBuf::from(path_string),
573 row,
574 column,
575 }
576 }
577 }
578 }
579
580 pub fn map_path<E>(
581 self,
582 mapping: impl FnOnce(PathBuf) -> Result<PathBuf, E>,
583 ) -> Result<PathWithPosition, E> {
584 Ok(PathWithPosition {
585 path: mapping(self.path)?,
586 row: self.row,
587 column: self.column,
588 })
589 }
590
591 pub fn to_string(&self, path_to_string: impl Fn(&PathBuf) -> String) -> String {
592 let path_string = path_to_string(&self.path);
593 if let Some(row) = self.row {
594 if let Some(column) = self.column {
595 format!("{path_string}:{row}:{column}")
596 } else {
597 format!("{path_string}:{row}")
598 }
599 } else {
600 path_string
601 }
602 }
603}
604
605#[derive(Clone, Debug)]
606pub struct PathMatcher {
607 sources: Vec<String>,
608 glob: GlobSet,
609 path_style: PathStyle,
610}
611
612// impl std::fmt::Display for PathMatcher {
613// fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
614// self.sources.fmt(f)
615// }
616// }
617
618impl PartialEq for PathMatcher {
619 fn eq(&self, other: &Self) -> bool {
620 self.sources.eq(&other.sources)
621 }
622}
623
624impl Eq for PathMatcher {}
625
626impl PathMatcher {
627 pub fn new(
628 globs: impl IntoIterator<Item = impl AsRef<str>>,
629 path_style: PathStyle,
630 ) -> Result<Self, globset::Error> {
631 let globs = globs
632 .into_iter()
633 .map(|as_str| Glob::new(as_str.as_ref()))
634 .collect::<Result<Vec<_>, _>>()?;
635 let sources = globs.iter().map(|glob| glob.glob().to_owned()).collect();
636 let mut glob_builder = GlobSetBuilder::new();
637 for single_glob in globs {
638 glob_builder.add(single_glob);
639 }
640 let glob = glob_builder.build()?;
641 Ok(PathMatcher {
642 glob,
643 sources,
644 path_style,
645 })
646 }
647
648 pub fn sources(&self) -> &[String] {
649 &self.sources
650 }
651
652 pub fn is_match<P: AsRef<Path>>(&self, other: P) -> bool {
653 let other_path = other.as_ref();
654 self.sources.iter().any(|source| {
655 let as_bytes = other_path.as_os_str().as_encoded_bytes();
656 as_bytes.starts_with(source.as_bytes()) || as_bytes.ends_with(source.as_bytes())
657 }) || self.glob.is_match(other_path)
658 || self.check_with_end_separator(other_path)
659 }
660
661 fn check_with_end_separator(&self, path: &Path) -> bool {
662 let path_str = path.to_string_lossy();
663 let separator = self.path_style.separator();
664 if path_str.ends_with(separator) {
665 false
666 } else {
667 self.glob.is_match(path_str.to_string() + separator)
668 }
669 }
670}
671
672impl Default for PathMatcher {
673 fn default() -> Self {
674 Self {
675 path_style: PathStyle::local(),
676 glob: GlobSet::empty(),
677 sources: vec![],
678 }
679 }
680}
681
682/// Custom character comparison that prioritizes lowercase for same letters
683fn compare_chars(a: char, b: char) -> Ordering {
684 // First compare case-insensitive
685 match a.to_ascii_lowercase().cmp(&b.to_ascii_lowercase()) {
686 Ordering::Equal => {
687 // If same letter, prioritize lowercase (lowercase < uppercase)
688 match (a.is_ascii_lowercase(), b.is_ascii_lowercase()) {
689 (true, false) => Ordering::Less, // lowercase comes first
690 (false, true) => Ordering::Greater, // uppercase comes after
691 _ => Ordering::Equal, // both same case or both non-ascii
692 }
693 }
694 other => other,
695 }
696}
697
698/// Compares two sequences of consecutive digits for natural sorting.
699///
700/// This function is a core component of natural sorting that handles numeric comparison
701/// in a way that feels natural to humans. It extracts and compares consecutive digit
702/// sequences from two iterators, handling various cases like leading zeros and very large numbers.
703///
704/// # Behavior
705///
706/// The function implements the following comparison rules:
707/// 1. Different numeric values: Compares by actual numeric value (e.g., "2" < "10")
708/// 2. Leading zeros: When values are equal, longer sequence wins (e.g., "002" > "2")
709/// 3. Large numbers: Falls back to string comparison for numbers that would overflow u128
710///
711/// # Examples
712///
713/// ```text
714/// "1" vs "2" -> Less (different values)
715/// "2" vs "10" -> Less (numeric comparison)
716/// "002" vs "2" -> Greater (leading zeros)
717/// "10" vs "010" -> Less (leading zeros)
718/// "999..." vs "1000..." -> Less (large number comparison)
719/// ```
720///
721/// # Implementation Details
722///
723/// 1. Extracts consecutive digits into strings
724/// 2. Compares sequence lengths for leading zero handling
725/// 3. For equal lengths, compares digit by digit
726/// 4. For different lengths:
727/// - Attempts numeric comparison first (for numbers up to 2^128 - 1)
728/// - Falls back to string comparison if numbers would overflow
729///
730/// The function advances both iterators past their respective numeric sequences,
731/// regardless of the comparison result.
732fn compare_numeric_segments<I>(
733 a_iter: &mut std::iter::Peekable<I>,
734 b_iter: &mut std::iter::Peekable<I>,
735) -> Ordering
736where
737 I: Iterator<Item = char>,
738{
739 // Collect all consecutive digits into strings
740 let mut a_num_str = String::new();
741 let mut b_num_str = String::new();
742
743 while let Some(&c) = a_iter.peek() {
744 if !c.is_ascii_digit() {
745 break;
746 }
747
748 a_num_str.push(c);
749 a_iter.next();
750 }
751
752 while let Some(&c) = b_iter.peek() {
753 if !c.is_ascii_digit() {
754 break;
755 }
756
757 b_num_str.push(c);
758 b_iter.next();
759 }
760
761 // First compare lengths (handle leading zeros)
762 match a_num_str.len().cmp(&b_num_str.len()) {
763 Ordering::Equal => {
764 // Same length, compare digit by digit
765 match a_num_str.cmp(&b_num_str) {
766 Ordering::Equal => Ordering::Equal,
767 ordering => ordering,
768 }
769 }
770
771 // Different lengths but same value means leading zeros
772 ordering => {
773 // Try parsing as numbers first
774 if let (Ok(a_val), Ok(b_val)) = (a_num_str.parse::<u128>(), b_num_str.parse::<u128>()) {
775 match a_val.cmp(&b_val) {
776 Ordering::Equal => ordering, // Same value, longer one is greater (leading zeros)
777 ord => ord,
778 }
779 } else {
780 // If parsing fails (overflow), compare as strings
781 a_num_str.cmp(&b_num_str)
782 }
783 }
784 }
785}
786
787/// Performs natural sorting comparison between two strings.
788///
789/// Natural sorting is an ordering that handles numeric sequences in a way that matches human expectations.
790/// For example, "file2" comes before "file10" (unlike standard lexicographic sorting).
791///
792/// # Characteristics
793///
794/// * Case-sensitive with lowercase priority: When comparing same letters, lowercase comes before uppercase
795/// * Numbers are compared by numeric value, not character by character
796/// * Leading zeros affect ordering when numeric values are equal
797/// * Can handle numbers larger than u128::MAX (falls back to string comparison)
798///
799/// # Algorithm
800///
801/// The function works by:
802/// 1. Processing strings character by character
803/// 2. When encountering digits, treating consecutive digits as a single number
804/// 3. Comparing numbers by their numeric value rather than lexicographically
805/// 4. For non-numeric characters, using case-sensitive comparison with lowercase priority
806fn natural_sort(a: &str, b: &str) -> Ordering {
807 let mut a_iter = a.chars().peekable();
808 let mut b_iter = b.chars().peekable();
809
810 loop {
811 match (a_iter.peek(), b_iter.peek()) {
812 (None, None) => return Ordering::Equal,
813 (None, _) => return Ordering::Less,
814 (_, None) => return Ordering::Greater,
815 (Some(&a_char), Some(&b_char)) => {
816 if a_char.is_ascii_digit() && b_char.is_ascii_digit() {
817 match compare_numeric_segments(&mut a_iter, &mut b_iter) {
818 Ordering::Equal => continue,
819 ordering => return ordering,
820 }
821 } else {
822 match compare_chars(a_char, b_char) {
823 Ordering::Equal => {
824 a_iter.next();
825 b_iter.next();
826 }
827 ordering => return ordering,
828 }
829 }
830 }
831 }
832 }
833}
834pub fn compare_rel_paths(
835 (path_a, a_is_file): (&RelPath, bool),
836 (path_b, b_is_file): (&RelPath, bool),
837) -> Ordering {
838 let mut components_a = path_a.components();
839 let mut components_b = path_b.components();
840
841 fn stem_and_extension(filename: &str) -> (Option<&str>, Option<&str>) {
842 if filename.is_empty() {
843 return (None, None);
844 }
845
846 match filename.rsplit_once('.') {
847 // Case 1: No dot was found. The entire name is the stem.
848 None => (Some(filename), None),
849
850 // Case 2: A dot was found.
851 Some((before, after)) => {
852 // This is the crucial check for dotfiles like ".bashrc".
853 // If `before` is empty, the dot was the first character.
854 // In that case, we revert to the "whole name is the stem" logic.
855 if before.is_empty() {
856 (Some(filename), None)
857 } else {
858 // Otherwise, we have a standard stem and extension.
859 (Some(before), Some(after))
860 }
861 }
862 }
863 }
864 loop {
865 match (components_a.next(), components_b.next()) {
866 (Some(component_a), Some(component_b)) => {
867 let a_is_file = a_is_file && components_a.rest().is_empty();
868 let b_is_file = b_is_file && components_b.rest().is_empty();
869
870 let ordering = a_is_file.cmp(&b_is_file).then_with(|| {
871 let (a_stem, a_extension) = a_is_file
872 .then(|| stem_and_extension(component_a))
873 .unwrap_or_default();
874 let path_string_a = if a_is_file { a_stem } else { Some(component_a) };
875
876 let (b_stem, b_extension) = b_is_file
877 .then(|| stem_and_extension(component_b))
878 .unwrap_or_default();
879 let path_string_b = if b_is_file { b_stem } else { Some(component_b) };
880
881 let compare_components = match (path_string_a, path_string_b) {
882 (Some(a), Some(b)) => natural_sort(&a, &b),
883 (Some(_), None) => Ordering::Greater,
884 (None, Some(_)) => Ordering::Less,
885 (None, None) => Ordering::Equal,
886 };
887
888 compare_components.then_with(|| {
889 if a_is_file && b_is_file {
890 let ext_a = a_extension.unwrap_or_default();
891 let ext_b = b_extension.unwrap_or_default();
892 ext_a.cmp(ext_b)
893 } else {
894 Ordering::Equal
895 }
896 })
897 });
898
899 if !ordering.is_eq() {
900 return ordering;
901 }
902 }
903 (Some(_), None) => break Ordering::Greater,
904 (None, Some(_)) => break Ordering::Less,
905 (None, None) => break Ordering::Equal,
906 }
907 }
908}
909
910pub fn compare_paths(
911 (path_a, a_is_file): (&Path, bool),
912 (path_b, b_is_file): (&Path, bool),
913) -> Ordering {
914 let mut components_a = path_a.components().peekable();
915 let mut components_b = path_b.components().peekable();
916
917 loop {
918 match (components_a.next(), components_b.next()) {
919 (Some(component_a), Some(component_b)) => {
920 let a_is_file = components_a.peek().is_none() && a_is_file;
921 let b_is_file = components_b.peek().is_none() && b_is_file;
922
923 let ordering = a_is_file.cmp(&b_is_file).then_with(|| {
924 let path_a = Path::new(component_a.as_os_str());
925 let path_string_a = if a_is_file {
926 path_a.file_stem()
927 } else {
928 path_a.file_name()
929 }
930 .map(|s| s.to_string_lossy());
931
932 let path_b = Path::new(component_b.as_os_str());
933 let path_string_b = if b_is_file {
934 path_b.file_stem()
935 } else {
936 path_b.file_name()
937 }
938 .map(|s| s.to_string_lossy());
939
940 let compare_components = match (path_string_a, path_string_b) {
941 (Some(a), Some(b)) => natural_sort(&a, &b),
942 (Some(_), None) => Ordering::Greater,
943 (None, Some(_)) => Ordering::Less,
944 (None, None) => Ordering::Equal,
945 };
946
947 compare_components.then_with(|| {
948 if a_is_file && b_is_file {
949 let ext_a = path_a.extension().unwrap_or_default();
950 let ext_b = path_b.extension().unwrap_or_default();
951 ext_a.cmp(ext_b)
952 } else {
953 Ordering::Equal
954 }
955 })
956 });
957
958 if !ordering.is_eq() {
959 return ordering;
960 }
961 }
962 (Some(_), None) => break Ordering::Greater,
963 (None, Some(_)) => break Ordering::Less,
964 (None, None) => break Ordering::Equal,
965 }
966 }
967}
968
969#[cfg(test)]
970mod tests {
971 use super::*;
972 use util_macros::perf;
973
974 #[perf]
975 fn compare_paths_with_dots() {
976 let mut paths = vec![
977 (Path::new("test_dirs"), false),
978 (Path::new("test_dirs/1.46"), false),
979 (Path::new("test_dirs/1.46/bar_1"), true),
980 (Path::new("test_dirs/1.46/bar_2"), true),
981 (Path::new("test_dirs/1.45"), false),
982 (Path::new("test_dirs/1.45/foo_2"), true),
983 (Path::new("test_dirs/1.45/foo_1"), true),
984 ];
985 paths.sort_by(|&a, &b| compare_paths(a, b));
986 assert_eq!(
987 paths,
988 vec![
989 (Path::new("test_dirs"), false),
990 (Path::new("test_dirs/1.45"), false),
991 (Path::new("test_dirs/1.45/foo_1"), true),
992 (Path::new("test_dirs/1.45/foo_2"), true),
993 (Path::new("test_dirs/1.46"), false),
994 (Path::new("test_dirs/1.46/bar_1"), true),
995 (Path::new("test_dirs/1.46/bar_2"), true),
996 ]
997 );
998 let mut paths = vec![
999 (Path::new("root1/one.txt"), true),
1000 (Path::new("root1/one.two.txt"), true),
1001 ];
1002 paths.sort_by(|&a, &b| compare_paths(a, b));
1003 assert_eq!(
1004 paths,
1005 vec![
1006 (Path::new("root1/one.txt"), true),
1007 (Path::new("root1/one.two.txt"), true),
1008 ]
1009 );
1010 }
1011
1012 #[perf]
1013 fn compare_paths_with_same_name_different_extensions() {
1014 let mut paths = vec![
1015 (Path::new("test_dirs/file.rs"), true),
1016 (Path::new("test_dirs/file.txt"), true),
1017 (Path::new("test_dirs/file.md"), true),
1018 (Path::new("test_dirs/file"), true),
1019 (Path::new("test_dirs/file.a"), true),
1020 ];
1021 paths.sort_by(|&a, &b| compare_paths(a, b));
1022 assert_eq!(
1023 paths,
1024 vec![
1025 (Path::new("test_dirs/file"), true),
1026 (Path::new("test_dirs/file.a"), true),
1027 (Path::new("test_dirs/file.md"), true),
1028 (Path::new("test_dirs/file.rs"), true),
1029 (Path::new("test_dirs/file.txt"), true),
1030 ]
1031 );
1032 }
1033
1034 #[perf]
1035 fn compare_paths_case_semi_sensitive() {
1036 let mut paths = vec![
1037 (Path::new("test_DIRS"), false),
1038 (Path::new("test_DIRS/foo_1"), true),
1039 (Path::new("test_DIRS/foo_2"), true),
1040 (Path::new("test_DIRS/bar"), true),
1041 (Path::new("test_DIRS/BAR"), true),
1042 (Path::new("test_dirs"), false),
1043 (Path::new("test_dirs/foo_1"), true),
1044 (Path::new("test_dirs/foo_2"), true),
1045 (Path::new("test_dirs/bar"), true),
1046 (Path::new("test_dirs/BAR"), true),
1047 ];
1048 paths.sort_by(|&a, &b| compare_paths(a, b));
1049 assert_eq!(
1050 paths,
1051 vec![
1052 (Path::new("test_dirs"), false),
1053 (Path::new("test_dirs/bar"), true),
1054 (Path::new("test_dirs/BAR"), true),
1055 (Path::new("test_dirs/foo_1"), true),
1056 (Path::new("test_dirs/foo_2"), true),
1057 (Path::new("test_DIRS"), false),
1058 (Path::new("test_DIRS/bar"), true),
1059 (Path::new("test_DIRS/BAR"), true),
1060 (Path::new("test_DIRS/foo_1"), true),
1061 (Path::new("test_DIRS/foo_2"), true),
1062 ]
1063 );
1064 }
1065
1066 #[perf]
1067 fn path_with_position_parse_posix_path() {
1068 // Test POSIX filename edge cases
1069 // Read more at https://en.wikipedia.org/wiki/Filename
1070 assert_eq!(
1071 PathWithPosition::parse_str("test_file"),
1072 PathWithPosition {
1073 path: PathBuf::from("test_file"),
1074 row: None,
1075 column: None
1076 }
1077 );
1078
1079 assert_eq!(
1080 PathWithPosition::parse_str("a:bc:.zip:1"),
1081 PathWithPosition {
1082 path: PathBuf::from("a:bc:.zip"),
1083 row: Some(1),
1084 column: None
1085 }
1086 );
1087
1088 assert_eq!(
1089 PathWithPosition::parse_str("one.second.zip:1"),
1090 PathWithPosition {
1091 path: PathBuf::from("one.second.zip"),
1092 row: Some(1),
1093 column: None
1094 }
1095 );
1096
1097 // Trim off trailing `:`s for otherwise valid input.
1098 assert_eq!(
1099 PathWithPosition::parse_str("test_file:10:1:"),
1100 PathWithPosition {
1101 path: PathBuf::from("test_file"),
1102 row: Some(10),
1103 column: Some(1)
1104 }
1105 );
1106
1107 assert_eq!(
1108 PathWithPosition::parse_str("test_file.rs:"),
1109 PathWithPosition {
1110 path: PathBuf::from("test_file.rs"),
1111 row: None,
1112 column: None
1113 }
1114 );
1115
1116 assert_eq!(
1117 PathWithPosition::parse_str("test_file.rs:1:"),
1118 PathWithPosition {
1119 path: PathBuf::from("test_file.rs"),
1120 row: Some(1),
1121 column: None
1122 }
1123 );
1124
1125 assert_eq!(
1126 PathWithPosition::parse_str("ab\ncd"),
1127 PathWithPosition {
1128 path: PathBuf::from("ab\ncd"),
1129 row: None,
1130 column: None
1131 }
1132 );
1133
1134 assert_eq!(
1135 PathWithPosition::parse_str("👋\nab"),
1136 PathWithPosition {
1137 path: PathBuf::from("👋\nab"),
1138 row: None,
1139 column: None
1140 }
1141 );
1142
1143 assert_eq!(
1144 PathWithPosition::parse_str("Types.hs:(617,9)-(670,28):"),
1145 PathWithPosition {
1146 path: PathBuf::from("Types.hs"),
1147 row: Some(617),
1148 column: Some(9),
1149 }
1150 );
1151 }
1152
1153 #[perf]
1154 #[cfg(not(target_os = "windows"))]
1155 fn path_with_position_parse_posix_path_with_suffix() {
1156 assert_eq!(
1157 PathWithPosition::parse_str("foo/bar:34:in"),
1158 PathWithPosition {
1159 path: PathBuf::from("foo/bar"),
1160 row: Some(34),
1161 column: None,
1162 }
1163 );
1164 assert_eq!(
1165 PathWithPosition::parse_str("foo/bar.rs:1902:::15:"),
1166 PathWithPosition {
1167 path: PathBuf::from("foo/bar.rs:1902"),
1168 row: Some(15),
1169 column: None
1170 }
1171 );
1172
1173 assert_eq!(
1174 PathWithPosition::parse_str("app-editors:zed-0.143.6:20240710-201212.log:34:"),
1175 PathWithPosition {
1176 path: PathBuf::from("app-editors:zed-0.143.6:20240710-201212.log"),
1177 row: Some(34),
1178 column: None,
1179 }
1180 );
1181
1182 assert_eq!(
1183 PathWithPosition::parse_str("crates/file_finder/src/file_finder.rs:1902:13:"),
1184 PathWithPosition {
1185 path: PathBuf::from("crates/file_finder/src/file_finder.rs"),
1186 row: Some(1902),
1187 column: Some(13),
1188 }
1189 );
1190
1191 assert_eq!(
1192 PathWithPosition::parse_str("crate/utils/src/test:today.log:34"),
1193 PathWithPosition {
1194 path: PathBuf::from("crate/utils/src/test:today.log"),
1195 row: Some(34),
1196 column: None,
1197 }
1198 );
1199 assert_eq!(
1200 PathWithPosition::parse_str("/testing/out/src/file_finder.odin(7:15)"),
1201 PathWithPosition {
1202 path: PathBuf::from("/testing/out/src/file_finder.odin"),
1203 row: Some(7),
1204 column: Some(15),
1205 }
1206 );
1207 }
1208
1209 #[perf]
1210 #[cfg(target_os = "windows")]
1211 fn path_with_position_parse_windows_path() {
1212 assert_eq!(
1213 PathWithPosition::parse_str("crates\\utils\\paths.rs"),
1214 PathWithPosition {
1215 path: PathBuf::from("crates\\utils\\paths.rs"),
1216 row: None,
1217 column: None
1218 }
1219 );
1220
1221 assert_eq!(
1222 PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs"),
1223 PathWithPosition {
1224 path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
1225 row: None,
1226 column: None
1227 }
1228 );
1229 }
1230
1231 #[perf]
1232 #[cfg(target_os = "windows")]
1233 fn path_with_position_parse_windows_path_with_suffix() {
1234 assert_eq!(
1235 PathWithPosition::parse_str("crates\\utils\\paths.rs:101"),
1236 PathWithPosition {
1237 path: PathBuf::from("crates\\utils\\paths.rs"),
1238 row: Some(101),
1239 column: None
1240 }
1241 );
1242
1243 assert_eq!(
1244 PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs:1:20"),
1245 PathWithPosition {
1246 path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
1247 row: Some(1),
1248 column: Some(20)
1249 }
1250 );
1251
1252 assert_eq!(
1253 PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs(1902,13)"),
1254 PathWithPosition {
1255 path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
1256 row: Some(1902),
1257 column: Some(13)
1258 }
1259 );
1260
1261 // Trim off trailing `:`s for otherwise valid input.
1262 assert_eq!(
1263 PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs:1902:13:"),
1264 PathWithPosition {
1265 path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
1266 row: Some(1902),
1267 column: Some(13)
1268 }
1269 );
1270
1271 assert_eq!(
1272 PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs:1902:13:15:"),
1273 PathWithPosition {
1274 path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs:1902"),
1275 row: Some(13),
1276 column: Some(15)
1277 }
1278 );
1279
1280 assert_eq!(
1281 PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs:1902:::15:"),
1282 PathWithPosition {
1283 path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs:1902"),
1284 row: Some(15),
1285 column: None
1286 }
1287 );
1288
1289 assert_eq!(
1290 PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs(1902,13):"),
1291 PathWithPosition {
1292 path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
1293 row: Some(1902),
1294 column: Some(13),
1295 }
1296 );
1297
1298 assert_eq!(
1299 PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs(1902):"),
1300 PathWithPosition {
1301 path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
1302 row: Some(1902),
1303 column: None,
1304 }
1305 );
1306
1307 assert_eq!(
1308 PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs:1902:13:"),
1309 PathWithPosition {
1310 path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
1311 row: Some(1902),
1312 column: Some(13),
1313 }
1314 );
1315
1316 assert_eq!(
1317 PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs(1902,13):"),
1318 PathWithPosition {
1319 path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
1320 row: Some(1902),
1321 column: Some(13),
1322 }
1323 );
1324
1325 assert_eq!(
1326 PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs(1902):"),
1327 PathWithPosition {
1328 path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
1329 row: Some(1902),
1330 column: None,
1331 }
1332 );
1333
1334 assert_eq!(
1335 PathWithPosition::parse_str("crates/utils/paths.rs:101"),
1336 PathWithPosition {
1337 path: PathBuf::from("crates\\utils\\paths.rs"),
1338 row: Some(101),
1339 column: None,
1340 }
1341 );
1342 }
1343
1344 #[perf]
1345 fn test_path_compact() {
1346 let path: PathBuf = [
1347 home_dir().to_string_lossy().into_owned(),
1348 "some_file.txt".to_string(),
1349 ]
1350 .iter()
1351 .collect();
1352 if cfg!(any(target_os = "linux", target_os = "freebsd")) || cfg!(target_os = "macos") {
1353 assert_eq!(path.compact().to_str(), Some("~/some_file.txt"));
1354 } else {
1355 assert_eq!(path.compact().to_str(), path.to_str());
1356 }
1357 }
1358
1359 #[perf]
1360 fn test_extension_or_hidden_file_name() {
1361 // No dots in name
1362 let path = Path::new("/a/b/c/file_name.rs");
1363 assert_eq!(path.extension_or_hidden_file_name(), Some("rs"));
1364
1365 // Single dot in name
1366 let path = Path::new("/a/b/c/file.name.rs");
1367 assert_eq!(path.extension_or_hidden_file_name(), Some("rs"));
1368
1369 // Multiple dots in name
1370 let path = Path::new("/a/b/c/long.file.name.rs");
1371 assert_eq!(path.extension_or_hidden_file_name(), Some("rs"));
1372
1373 // Hidden file, no extension
1374 let path = Path::new("/a/b/c/.gitignore");
1375 assert_eq!(path.extension_or_hidden_file_name(), Some("gitignore"));
1376
1377 // Hidden file, with extension
1378 let path = Path::new("/a/b/c/.eslintrc.js");
1379 assert_eq!(path.extension_or_hidden_file_name(), Some("eslintrc.js"));
1380 }
1381
1382 #[perf]
1383 fn edge_of_glob() {
1384 let path = Path::new("/work/node_modules");
1385 let path_matcher =
1386 PathMatcher::new(&["**/node_modules/**".to_owned()], PathStyle::Posix).unwrap();
1387 assert!(
1388 path_matcher.is_match(path),
1389 "Path matcher should match {path:?}"
1390 );
1391 }
1392
1393 #[perf]
1394 fn project_search() {
1395 let path = Path::new("/Users/someonetoignore/work/zed/zed.dev/node_modules");
1396 let path_matcher =
1397 PathMatcher::new(&["**/node_modules/**".to_owned()], PathStyle::Posix).unwrap();
1398 assert!(
1399 path_matcher.is_match(path),
1400 "Path matcher should match {path:?}"
1401 );
1402 }
1403
1404 #[perf]
1405 #[cfg(target_os = "windows")]
1406 fn test_sanitized_path() {
1407 let path = Path::new("C:\\Users\\someone\\test_file.rs");
1408 let sanitized_path = SanitizedPath::new(path);
1409 assert_eq!(
1410 sanitized_path.to_string(),
1411 "C:\\Users\\someone\\test_file.rs"
1412 );
1413
1414 let path = Path::new("\\\\?\\C:\\Users\\someone\\test_file.rs");
1415 let sanitized_path = SanitizedPath::new(path);
1416 assert_eq!(
1417 sanitized_path.to_string(),
1418 "C:\\Users\\someone\\test_file.rs"
1419 );
1420 }
1421
1422 #[perf]
1423 fn test_compare_numeric_segments() {
1424 // Helper function to create peekable iterators and test
1425 fn compare(a: &str, b: &str) -> Ordering {
1426 let mut a_iter = a.chars().peekable();
1427 let mut b_iter = b.chars().peekable();
1428
1429 let result = compare_numeric_segments(&mut a_iter, &mut b_iter);
1430
1431 // Verify iterators advanced correctly
1432 assert!(
1433 !a_iter.next().is_some_and(|c| c.is_ascii_digit()),
1434 "Iterator a should have consumed all digits"
1435 );
1436 assert!(
1437 !b_iter.next().is_some_and(|c| c.is_ascii_digit()),
1438 "Iterator b should have consumed all digits"
1439 );
1440
1441 result
1442 }
1443
1444 // Basic numeric comparisons
1445 assert_eq!(compare("0", "0"), Ordering::Equal);
1446 assert_eq!(compare("1", "2"), Ordering::Less);
1447 assert_eq!(compare("9", "10"), Ordering::Less);
1448 assert_eq!(compare("10", "9"), Ordering::Greater);
1449 assert_eq!(compare("99", "100"), Ordering::Less);
1450
1451 // Leading zeros
1452 assert_eq!(compare("0", "00"), Ordering::Less);
1453 assert_eq!(compare("00", "0"), Ordering::Greater);
1454 assert_eq!(compare("01", "1"), Ordering::Greater);
1455 assert_eq!(compare("001", "1"), Ordering::Greater);
1456 assert_eq!(compare("001", "01"), Ordering::Greater);
1457
1458 // Same value different representation
1459 assert_eq!(compare("000100", "100"), Ordering::Greater);
1460 assert_eq!(compare("100", "0100"), Ordering::Less);
1461 assert_eq!(compare("0100", "00100"), Ordering::Less);
1462
1463 // Large numbers
1464 assert_eq!(compare("9999999999", "10000000000"), Ordering::Less);
1465 assert_eq!(
1466 compare(
1467 "340282366920938463463374607431768211455", // u128::MAX
1468 "340282366920938463463374607431768211456"
1469 ),
1470 Ordering::Less
1471 );
1472 assert_eq!(
1473 compare(
1474 "340282366920938463463374607431768211456", // > u128::MAX
1475 "340282366920938463463374607431768211455"
1476 ),
1477 Ordering::Greater
1478 );
1479
1480 // Iterator advancement verification
1481 let mut a_iter = "123abc".chars().peekable();
1482 let mut b_iter = "456def".chars().peekable();
1483
1484 compare_numeric_segments(&mut a_iter, &mut b_iter);
1485
1486 assert_eq!(a_iter.collect::<String>(), "abc");
1487 assert_eq!(b_iter.collect::<String>(), "def");
1488 }
1489
1490 #[perf]
1491 fn test_natural_sort() {
1492 // Basic alphanumeric
1493 assert_eq!(natural_sort("a", "b"), Ordering::Less);
1494 assert_eq!(natural_sort("b", "a"), Ordering::Greater);
1495 assert_eq!(natural_sort("a", "a"), Ordering::Equal);
1496
1497 // Case sensitivity
1498 assert_eq!(natural_sort("a", "A"), Ordering::Less);
1499 assert_eq!(natural_sort("A", "a"), Ordering::Greater);
1500 assert_eq!(natural_sort("aA", "aa"), Ordering::Greater);
1501 assert_eq!(natural_sort("aa", "aA"), Ordering::Less);
1502
1503 // Numbers
1504 assert_eq!(natural_sort("1", "2"), Ordering::Less);
1505 assert_eq!(natural_sort("2", "10"), Ordering::Less);
1506 assert_eq!(natural_sort("02", "10"), Ordering::Less);
1507 assert_eq!(natural_sort("02", "2"), Ordering::Greater);
1508
1509 // Mixed alphanumeric
1510 assert_eq!(natural_sort("a1", "a2"), Ordering::Less);
1511 assert_eq!(natural_sort("a2", "a10"), Ordering::Less);
1512 assert_eq!(natural_sort("a02", "a2"), Ordering::Greater);
1513 assert_eq!(natural_sort("a1b", "a1c"), Ordering::Less);
1514
1515 // Multiple numeric segments
1516 assert_eq!(natural_sort("1a2", "1a10"), Ordering::Less);
1517 assert_eq!(natural_sort("1a10", "1a2"), Ordering::Greater);
1518 assert_eq!(natural_sort("2a1", "10a1"), Ordering::Less);
1519
1520 // Special characters
1521 assert_eq!(natural_sort("a-1", "a-2"), Ordering::Less);
1522 assert_eq!(natural_sort("a_1", "a_2"), Ordering::Less);
1523 assert_eq!(natural_sort("a.1", "a.2"), Ordering::Less);
1524
1525 // Unicode
1526 assert_eq!(natural_sort("文1", "文2"), Ordering::Less);
1527 assert_eq!(natural_sort("文2", "文10"), Ordering::Less);
1528 assert_eq!(natural_sort("🔤1", "🔤2"), Ordering::Less);
1529
1530 // Empty and special cases
1531 assert_eq!(natural_sort("", ""), Ordering::Equal);
1532 assert_eq!(natural_sort("", "a"), Ordering::Less);
1533 assert_eq!(natural_sort("a", ""), Ordering::Greater);
1534 assert_eq!(natural_sort(" ", " "), Ordering::Less);
1535
1536 // Mixed everything
1537 assert_eq!(natural_sort("File-1.txt", "File-2.txt"), Ordering::Less);
1538 assert_eq!(natural_sort("File-02.txt", "File-2.txt"), Ordering::Greater);
1539 assert_eq!(natural_sort("File-2.txt", "File-10.txt"), Ordering::Less);
1540 assert_eq!(natural_sort("File_A1", "File_A2"), Ordering::Less);
1541 assert_eq!(natural_sort("File_a1", "File_A1"), Ordering::Less);
1542 }
1543
1544 #[perf]
1545 fn test_compare_paths() {
1546 // Helper function for cleaner tests
1547 fn compare(a: &str, is_a_file: bool, b: &str, is_b_file: bool) -> Ordering {
1548 compare_paths((Path::new(a), is_a_file), (Path::new(b), is_b_file))
1549 }
1550
1551 // Basic path comparison
1552 assert_eq!(compare("a", true, "b", true), Ordering::Less);
1553 assert_eq!(compare("b", true, "a", true), Ordering::Greater);
1554 assert_eq!(compare("a", true, "a", true), Ordering::Equal);
1555
1556 // Files vs Directories
1557 assert_eq!(compare("a", true, "a", false), Ordering::Greater);
1558 assert_eq!(compare("a", false, "a", true), Ordering::Less);
1559 assert_eq!(compare("b", false, "a", true), Ordering::Less);
1560
1561 // Extensions
1562 assert_eq!(compare("a.txt", true, "a.md", true), Ordering::Greater);
1563 assert_eq!(compare("a.md", true, "a.txt", true), Ordering::Less);
1564 assert_eq!(compare("a", true, "a.txt", true), Ordering::Less);
1565
1566 // Nested paths
1567 assert_eq!(compare("dir/a", true, "dir/b", true), Ordering::Less);
1568 assert_eq!(compare("dir1/a", true, "dir2/a", true), Ordering::Less);
1569 assert_eq!(compare("dir/sub/a", true, "dir/a", true), Ordering::Less);
1570
1571 // Case sensitivity in paths
1572 assert_eq!(
1573 compare("Dir/file", true, "dir/file", true),
1574 Ordering::Greater
1575 );
1576 assert_eq!(
1577 compare("dir/File", true, "dir/file", true),
1578 Ordering::Greater
1579 );
1580 assert_eq!(compare("dir/file", true, "Dir/File", true), Ordering::Less);
1581
1582 // Hidden files and special names
1583 assert_eq!(compare(".hidden", true, "visible", true), Ordering::Less);
1584 assert_eq!(compare("_special", true, "normal", true), Ordering::Less);
1585 assert_eq!(compare(".config", false, ".data", false), Ordering::Less);
1586
1587 // Mixed numeric paths
1588 assert_eq!(
1589 compare("dir1/file", true, "dir2/file", true),
1590 Ordering::Less
1591 );
1592 assert_eq!(
1593 compare("dir2/file", true, "dir10/file", true),
1594 Ordering::Less
1595 );
1596 assert_eq!(
1597 compare("dir02/file", true, "dir2/file", true),
1598 Ordering::Greater
1599 );
1600
1601 // Root paths
1602 assert_eq!(compare("/a", true, "/b", true), Ordering::Less);
1603 assert_eq!(compare("/", false, "/a", true), Ordering::Less);
1604
1605 // Complex real-world examples
1606 assert_eq!(
1607 compare("project/src/main.rs", true, "project/src/lib.rs", true),
1608 Ordering::Greater
1609 );
1610 assert_eq!(
1611 compare(
1612 "project/tests/test_1.rs",
1613 true,
1614 "project/tests/test_2.rs",
1615 true
1616 ),
1617 Ordering::Less
1618 );
1619 assert_eq!(
1620 compare(
1621 "project/v1.0.0/README.md",
1622 true,
1623 "project/v1.10.0/README.md",
1624 true
1625 ),
1626 Ordering::Less
1627 );
1628 }
1629
1630 #[perf]
1631 fn test_natural_sort_case_sensitivity() {
1632 std::thread::sleep(std::time::Duration::from_millis(100));
1633 // Same letter different case - lowercase should come first
1634 assert_eq!(natural_sort("a", "A"), Ordering::Less);
1635 assert_eq!(natural_sort("A", "a"), Ordering::Greater);
1636 assert_eq!(natural_sort("a", "a"), Ordering::Equal);
1637 assert_eq!(natural_sort("A", "A"), Ordering::Equal);
1638
1639 // Mixed case strings
1640 assert_eq!(natural_sort("aaa", "AAA"), Ordering::Less);
1641 assert_eq!(natural_sort("AAA", "aaa"), Ordering::Greater);
1642 assert_eq!(natural_sort("aAa", "AaA"), Ordering::Less);
1643
1644 // Different letters
1645 assert_eq!(natural_sort("a", "b"), Ordering::Less);
1646 assert_eq!(natural_sort("A", "b"), Ordering::Less);
1647 assert_eq!(natural_sort("a", "B"), Ordering::Less);
1648 }
1649
1650 #[perf]
1651 fn test_natural_sort_with_numbers() {
1652 // Basic number ordering
1653 assert_eq!(natural_sort("file1", "file2"), Ordering::Less);
1654 assert_eq!(natural_sort("file2", "file10"), Ordering::Less);
1655 assert_eq!(natural_sort("file10", "file2"), Ordering::Greater);
1656
1657 // Numbers in different positions
1658 assert_eq!(natural_sort("1file", "2file"), Ordering::Less);
1659 assert_eq!(natural_sort("file1text", "file2text"), Ordering::Less);
1660 assert_eq!(natural_sort("text1file", "text2file"), Ordering::Less);
1661
1662 // Multiple numbers in string
1663 assert_eq!(natural_sort("file1-2", "file1-10"), Ordering::Less);
1664 assert_eq!(natural_sort("2-1file", "10-1file"), Ordering::Less);
1665
1666 // Leading zeros
1667 assert_eq!(natural_sort("file002", "file2"), Ordering::Greater);
1668 assert_eq!(natural_sort("file002", "file10"), Ordering::Less);
1669
1670 // Very large numbers
1671 assert_eq!(
1672 natural_sort("file999999999999999999999", "file999999999999999999998"),
1673 Ordering::Greater
1674 );
1675
1676 // u128 edge cases
1677
1678 // Numbers near u128::MAX (340,282,366,920,938,463,463,374,607,431,768,211,455)
1679 assert_eq!(
1680 natural_sort(
1681 "file340282366920938463463374607431768211454",
1682 "file340282366920938463463374607431768211455"
1683 ),
1684 Ordering::Less
1685 );
1686
1687 // Equal length numbers that overflow u128
1688 assert_eq!(
1689 natural_sort(
1690 "file340282366920938463463374607431768211456",
1691 "file340282366920938463463374607431768211455"
1692 ),
1693 Ordering::Greater
1694 );
1695
1696 // Different length numbers that overflow u128
1697 assert_eq!(
1698 natural_sort(
1699 "file3402823669209384634633746074317682114560",
1700 "file340282366920938463463374607431768211455"
1701 ),
1702 Ordering::Greater
1703 );
1704
1705 // Leading zeros with numbers near u128::MAX
1706 assert_eq!(
1707 natural_sort(
1708 "file0340282366920938463463374607431768211455",
1709 "file340282366920938463463374607431768211455"
1710 ),
1711 Ordering::Greater
1712 );
1713
1714 // Very large numbers with different lengths (both overflow u128)
1715 assert_eq!(
1716 natural_sort(
1717 "file999999999999999999999999999999999999999999999999",
1718 "file9999999999999999999999999999999999999999999999999"
1719 ),
1720 Ordering::Less
1721 );
1722
1723 // Mixed case with numbers
1724 assert_eq!(natural_sort("File1", "file2"), Ordering::Greater);
1725 assert_eq!(natural_sort("file1", "File2"), Ordering::Less);
1726 }
1727
1728 #[perf]
1729 fn test_natural_sort_edge_cases() {
1730 // Empty strings
1731 assert_eq!(natural_sort("", ""), Ordering::Equal);
1732 assert_eq!(natural_sort("", "a"), Ordering::Less);
1733 assert_eq!(natural_sort("a", ""), Ordering::Greater);
1734
1735 // Special characters
1736 assert_eq!(natural_sort("file-1", "file_1"), Ordering::Less);
1737 assert_eq!(natural_sort("file.1", "file_1"), Ordering::Less);
1738 assert_eq!(natural_sort("file 1", "file_1"), Ordering::Less);
1739
1740 // Unicode characters
1741 // 9312 vs 9313
1742 assert_eq!(natural_sort("file①", "file②"), Ordering::Less);
1743 // 9321 vs 9313
1744 assert_eq!(natural_sort("file⑩", "file②"), Ordering::Greater);
1745 // 28450 vs 23383
1746 assert_eq!(natural_sort("file漢", "file字"), Ordering::Greater);
1747
1748 // Mixed alphanumeric with special chars
1749 assert_eq!(natural_sort("file-1a", "file-1b"), Ordering::Less);
1750 assert_eq!(natural_sort("file-1.2", "file-1.10"), Ordering::Less);
1751 assert_eq!(natural_sort("file-1.10", "file-1.2"), Ordering::Greater);
1752 }
1753
1754 #[test]
1755 fn test_multiple_extensions() {
1756 // No extensions
1757 let path = Path::new("/a/b/c/file_name");
1758 assert_eq!(path.multiple_extensions(), None);
1759
1760 // Only one extension
1761 let path = Path::new("/a/b/c/file_name.tsx");
1762 assert_eq!(path.multiple_extensions(), None);
1763
1764 // Stories sample extension
1765 let path = Path::new("/a/b/c/file_name.stories.tsx");
1766 assert_eq!(path.multiple_extensions(), Some("stories.tsx".to_string()));
1767
1768 // Longer sample extension
1769 let path = Path::new("/a/b/c/long.app.tar.gz");
1770 assert_eq!(path.multiple_extensions(), Some("app.tar.gz".to_string()));
1771 }
1772}