Normalize drive letters when resolving paths on Windows

When it comes to resolving paths on Windows, even though the underlying
API expects drive letter prefixes to be uppercase, some sources (e.g.
environment variables like `=C:`) won't normalize components, instead
returning the value as-is. While this wouldn't be a problem normally as
NTFS is case-insensitive on Windows, this introduces duplicates in the
database when adding new entries via `zoxide add`:

```batchfile prompt
> zoxide query --list
D:\
d:\
D:\coding
d:\coding
D:\coding\.cloned
d:\coding\.cloned
```

This is a cherry-pick from ajeetdsouza#567; see also rust-lang/rust-analyzer#14683.

Signed-off-by: mataha <[email protected]>

Author: mataha

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - zsh: better cd completions.
 - elvish: `z -` now work as expected.
 - Lazily delete excluded directories from the database.
+- Normalize drive letters when resolving paths on Windows.
 
 ## [0.9.4] - 2024-02-21
 

src/util.rs

@@ -292,43 +292,72 @@ pub fn resolve_path(path: impl AsRef<Path>) -> Result<PathBuf> {
         }
 
         fn get_drive_path(drive_letter: u8) -> PathBuf {
-            format!(r"{}:\", drive_letter as char).into()
+            format!(r"{}:\", drive_letter.to_ascii_uppercase() as char).into()
         }
 
         fn get_drive_relative(drive_letter: u8) -> Result<PathBuf> {
             let path = current_dir()?;
             if Some(drive_letter) == get_drive_letter(&path) {
-                return Ok(path);
+                return Ok(patch_drive_prefix(path));
             }
 
-            if let Some(path) = env::var_os(format!("={}:", drive_letter as char)) {
-                return Ok(path.into());
+            if let Some(path) =
+                env::var_os(format!("={}:", drive_letter.to_ascii_uppercase() as char))
+            {
+                return Ok(patch_drive_prefix(path.into()));
             }
 
             let path = get_drive_path(drive_letter);
             Ok(path)
         }
 
+        // https://github.com/rust-lang/rust-analyzer/pull/14689
+        fn patch_drive_prefix(path: PathBuf) -> PathBuf {
+            let mut components = path.components();
+
+            match components.next() {
+                Some(Component::Prefix(prefix)) => {
+                    let prefix = match prefix.kind() {
+                        Prefix::Disk(drive_letter) => {
+                            format!(r"{}:", drive_letter.to_ascii_uppercase() as char)
+                        }
+                        Prefix::VerbatimDisk(drive_letter) => {
+                            format!(r"\\?\{}:", drive_letter.to_ascii_uppercase() as char)
+                        }
+                        _ => return path,
+                    };
+
+                    let mut path = PathBuf::default();
+                    path.push(prefix);
+                    path.extend(components);
+                    path
+                }
+                _ => path,
+            }
+        }
+
         match components.peek() {
             Some(Component::Prefix(prefix)) => match prefix.kind() {
                 Prefix::Disk(drive_letter) => {
-                    let disk = components.next().unwrap();
+                    components.next();
                     if components.peek() == Some(&Component::RootDir) {
-                        let root = components.next().unwrap();
-                        stack.push(disk);
-                        stack.push(root);
+                        components.next();
+                        base_path = get_drive_path(drive_letter);
                     } else {
                         base_path = get_drive_relative(drive_letter)?;
-                        stack.extend(base_path.components());
                     }
+
+                    stack.extend(base_path.components());
                 }
                 Prefix::VerbatimDisk(drive_letter) => {
                     components.next();
                     if components.peek() == Some(&Component::RootDir) {
                         components.next();
+                        base_path = get_drive_path(drive_letter);
+                    } else {
+                        bail!("illegal path: {}", path.display());
                     }
 
-                    base_path = get_drive_path(drive_letter);
                     stack.extend(base_path.components());
                 }
                 _ => bail!("invalid path: {}", path.display()),