refactor(path): add shared strip_path_prefix helper

Co-authored-by: GPT-5 Codex <codex@openai.com>

Author: wan9chi

Cargo.lock

@@ -16,10 +16,10 @@ shared_memory = { workspace = true, features = ["logging"] }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }
+vite_path = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 bytemuck = { workspace = true }
-os_str_bytes = { workspace = true }
 winapi = { workspace = true, features = ["std"] }
 
 [dev-dependencies]

crates/fspy_shared/Cargo.toml

@@ -1,7 +1,8 @@
 #[cfg(unix)]
+use std::ffi::OsStr;
+#[cfg(unix)]
 use std::os::unix::ffi::OsStrExt as _;
 use std::{
-    ffi::OsStr,
     fmt::Debug,
     mem::MaybeUninit,
     path::{Path, StripPrefixError},
@@ -70,41 +71,8 @@ impl NativePath {
         base: P,
         f: F,
     ) -> R {
-        /// Strip the `\\?\`, `\\.\`, `\??\` prefix from a Windows path, if present.
-        /// Does nothing on non-Windows platforms.
-        ///
-        /// \\?\ and \\.\ are used to enable long paths and access to device paths.
-        /// \??\ is used in Nt* calls.
-        /// The resulting path is not necessarily valid or points to the same location,
-        /// but it's good enough for sanitizing paths in `NativePath::strip_path_prefix`.
-        #[cfg_attr(
-            not(windows),
-            expect(
-                clippy::missing_const_for_fn,
-                reason = "uses non-const for loop and strip_prefix on Windows"
-            )
-        )]
-        fn strip_windows_path_prefix(p: &OsStr) -> &OsStr {
-            #[cfg(windows)]
-            {
-                use os_str_bytes::OsStrBytesExt as _;
-                for prefix in [r"\\?\", r"\\.\", r"\??\"] {
-                    if let Some(stripped) = p.strip_prefix(prefix) {
-                        return stripped;
-                    }
-                }
-                p
-            }
-            #[cfg(not(windows))]
-            {
-                p
-            }
-        }
-
         let me = self.inner.to_cow_os_str();
-        let me = strip_windows_path_prefix(&me);
-        let base = strip_windows_path_prefix(base.as_ref().as_os_str());
-        f(Path::new(me).strip_prefix(base))
+        f(vite_path::strip_path_prefix(&me, base.as_ref().as_os_str()))
     }
 }
 

crates/fspy_shared/src/ipc/native_path.rs

@@ -17,6 +17,9 @@ thiserror = { workspace = true }
 ts-rs = { workspace = true, optional = true }
 vite_str = { workspace = true }
 
+[target.'cfg(target_os = "windows")'.dependencies]
+os_str_bytes = { workspace = true }
+
 [features]
 absolute-redaction = []
 ts-rs = ["dep:ts-rs", "vite_str/ts-rs"]

crates/vite_path/Cargo.toml

@@ -163,15 +163,32 @@ impl AbsolutePath {
         let Ok(stripped_path) = self.0.strip_prefix(&base.0) else {
             return Ok(None);
         };
-        match RelativePathBuf::new(stripped_path) {
-            Ok(relative_path) => Ok(Some(relative_path)),
-            Err(FromPathError::NonRelative) => {
-                unreachable!("stripped path should always be relative")
-            }
-            Err(FromPathError::InvalidPathData(invalid_path_data_error)) => {
-                Err(StripPrefixError { stripped_path, invalid_path_data_error })
-            }
-        }
+        stripped_path_to_relative(stripped_path).map(Some)
+    }
+
+    /// Returns a path that, when joined onto base, yields self.
+    ///
+    /// Unlike [`AbsolutePath::strip_prefix`], this normalizes Windows path
+    /// namespace prefixes (`\\?\`, `\\.\`, and `\??\`) before matching.
+    ///
+    /// If `base` is not a prefix of `self`, returns [`None`].
+    ///
+    /// If the stripped path is not a valid `RelativePath`. Returns an error with the reason and the stripped path.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the stripped path contains invalid UTF-8 or other path data issues.
+    pub fn strip_path_prefix<P: AsRef<Self>>(
+        &self,
+        base: P,
+    ) -> Result<Option<RelativePathBuf>, StripPrefixError<'_>> {
+        let base = base.as_ref();
+        let Ok(stripped_path) =
+            crate::strip_path_prefix(self.as_path().as_os_str(), base.as_path().as_os_str())
+        else {
+            return Ok(None);
+        };
+        stripped_path_to_relative(stripped_path).map(Some)
     }
 
     /// Creates an owned [`AbsolutePathBuf`] with `path` adjoined to `self`.
@@ -220,6 +237,20 @@ impl AbsolutePath {
     }
 }
 
+fn stripped_path_to_relative(
+    stripped_path: &Path,
+) -> Result<RelativePathBuf, StripPrefixError<'_>> {
+    match RelativePathBuf::new(stripped_path) {
+        Ok(relative_path) => Ok(relative_path),
+        Err(FromPathError::NonRelative) => {
+            unreachable!("stripped path should always be relative")
+        }
+        Err(FromPathError::InvalidPathData(invalid_path_data_error)) => {
+            Err(StripPrefixError { stripped_path, invalid_path_data_error })
+        }
+    }
+}
+
 /// An Error returned from [`AbsolutePath::strip_prefix`] if the stripped path is not a valid `RelativePath`
 #[derive(thiserror::Error, Debug)]
 pub struct StripPrefixError<'a> {
@@ -397,6 +428,54 @@ mod tests {
         assert!(rel_path.is_none());
     }
 
+    #[test]
+    fn strip_path_prefix() {
+        let abs_path = AbsolutePath::new(Path::new(if cfg!(windows) {
+            "C:\\Users\\foo\\bar"
+        } else {
+            "/home/foo/bar"
+        }))
+        .unwrap();
+
+        let prefix =
+            AbsolutePath::new(Path::new(if cfg!(windows) { "C:\\Users" } else { "/home" }))
+                .unwrap();
+
+        let rel_path = abs_path.strip_path_prefix(prefix).unwrap().unwrap();
+        assert_eq!(rel_path.as_str(), "foo/bar");
+    }
+
+    #[test]
+    fn strip_path_prefix_not_found() {
+        let abs_path = AbsolutePath::new(Path::new(if cfg!(windows) {
+            "C:\\Users\\foo\\bar"
+        } else {
+            "/home/foo/bar"
+        }))
+        .unwrap();
+
+        let prefix = AbsolutePath::new(Path::new(if cfg!(windows) {
+            "C:\\Users\\barz"
+        } else {
+            "/home/baz"
+        }))
+        .unwrap();
+
+        let rel_path = abs_path.strip_path_prefix(prefix).unwrap();
+        assert!(rel_path.is_none());
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn strip_path_prefix_ignores_windows_namespace_prefixes() {
+        let abs_path = AbsolutePath::new(Path::new(r"\\?\C:\Users\foo\bar")).unwrap();
+        let prefix = AbsolutePath::new(Path::new(r"C:\Users")).unwrap();
+
+        let rel_path = abs_path.strip_path_prefix(prefix).unwrap().unwrap();
+
+        assert_eq!(rel_path.as_str(), "foo/bar");
+    }
+
     #[cfg(unix)]
     #[test]
     fn strip_prefix_invalid_relative() {

crates/vite_path/src/absolute/mod.rs

@@ -3,7 +3,11 @@
 pub mod absolute;
 pub mod relative;
 
-use std::io;
+use std::{
+    ffi::OsStr,
+    io,
+    path::{Path, StripPrefixError},
+};
 
 #[cfg(feature = "absolute-redaction")]
 pub use absolute::redaction;
@@ -31,3 +35,93 @@ pub fn current_dir() -> io::Result<AbsolutePathBuf> {
     // Do a runtime check just in case.
     Ok(AbsolutePathBuf::new(cwd).unwrap())
 }
+
+/// Strips `base` from `path`, after normalizing Windows path namespace prefixes.
+///
+/// On Windows, the `\\?\`, `\\.\`, and `\??\` prefixes are ignored before
+/// matching. On other platforms this is equivalent to [`Path::strip_prefix`].
+///
+/// This is purely lexical and does not access the filesystem.
+///
+/// # Errors
+///
+/// Returns an error if `base` is not a path prefix of `path` after applying the
+/// platform-specific prefix normalization above.
+pub fn strip_path_prefix<'a>(path: &'a OsStr, base: &OsStr) -> Result<&'a Path, StripPrefixError> {
+    let path = strip_windows_path_prefix(path);
+    let base = strip_windows_path_prefix(base);
+    Path::new(path).strip_prefix(base)
+}
+
+/// Strip the `\\?\`, `\\.\`, `\??\` prefix from a Windows path, if present.
+/// Does nothing on non-Windows platforms.
+///
+/// `\\?\` and `\\.\` are used to enable long paths and access to device paths.
+/// `\??\` is used in Nt* calls.
+/// The resulting path is not necessarily valid or points to the same location,
+/// but it is enough for lexical path-prefix comparisons.
+#[cfg_attr(
+    not(windows),
+    expect(
+        clippy::missing_const_for_fn,
+        reason = "uses non-const for loop and strip_prefix on Windows"
+    )
+)]
+fn strip_windows_path_prefix(p: &OsStr) -> &OsStr {
+    #[cfg(windows)]
+    {
+        use os_str_bytes::OsStrBytesExt as _;
+
+        for prefix in [r"\\?\", r"\\.\", r"\??\"] {
+            if let Some(stripped) = p.strip_prefix(prefix) {
+                return stripped;
+            }
+        }
+        p
+    }
+    #[cfg(not(windows))]
+    {
+        p
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ffi::OsStr;
+
+    use super::*;
+
+    #[test]
+    fn strip_path_prefix_strips_base() {
+        let path =
+            OsStr::new(if cfg!(windows) { r"C:\repo\pkg\file.txt" } else { "/repo/pkg/file.txt" });
+        let base = OsStr::new(if cfg!(windows) { r"C:\repo" } else { "/repo" });
+
+        let stripped = strip_path_prefix(path, base).unwrap();
+
+        assert_eq!(
+            stripped,
+            Path::new(if cfg!(windows) { r"pkg\file.txt" } else { "pkg/file.txt" })
+        );
+    }
+
+    #[test]
+    fn strip_path_prefix_reports_mismatch() {
+        let path =
+            OsStr::new(if cfg!(windows) { r"C:\repo\pkg\file.txt" } else { "/repo/pkg/file.txt" });
+        let base = OsStr::new(if cfg!(windows) { r"C:\other" } else { "/other" });
+
+        assert!(strip_path_prefix(path, base).is_err());
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn strip_path_prefix_ignores_windows_namespace_prefixes() {
+        let path = OsStr::new(r"\??\C:\repo\pkg\file.txt");
+        let base = OsStr::new(r"\\?\C:\repo");
+
+        let stripped = strip_path_prefix(path, base).unwrap();
+
+        assert_eq!(stripped, Path::new(r"pkg\file.txt"));
+    }
+}