Inlines the arca dependency

Author: arcanis

Cargo.lock

@@ -10,13 +10,16 @@ repository = "https://github.com/yarnpkg/pnp-rs"
 [dependencies]
 arca = "^0.7"
 byteorder = "1"
+clean-path = "0.2.1"
 concurrent_lru = "^0.2"
 fancy-regex = "^0.13.0"
 indexmap = { version = "2.7.1", features = ["serde"] }
 lazy_static = "1"
 miniz_oxide = "^0.7"
 mmap-rs = { version = "^0.6", optional = true }
+path-slash = "0.2.1"
 pathdiff = "^0.2"
+radix_trie = "0.2.1"
 regex = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

Cargo.toml

@@ -225,7 +225,7 @@ fn split_virtual(p_bytes: &[u8]) -> std::io::Result<(usize, Option<(usize, usize
 }
 
 fn vpath(p: &Path) -> std::io::Result<VPath> {
-    let p_str = arca::path::normalize_path(
+    let p_str = crate::util::normalize_path(
         &p.as_os_str()
             .to_string_lossy()
     );
@@ -303,6 +303,8 @@ mod tests {
     use rstest::rstest;
     use std::path::PathBuf;
 
+    use crate::util;
+
     use super::*;
 
     #[test]
@@ -445,7 +447,7 @@ mod tests {
     fn test_path_to_pnp(#[case] input: &str, #[case] expected: Option<VPath>) {
         let expectation: VPath = match &expected {
             Some(p) => p.clone(),
-            None => VPath::Native(PathBuf::from(arca::path::normalize_path(input))),
+            None => VPath::Native(PathBuf::from(util::normalize_path(input))),
         };
 
         match vpath(&PathBuf::from(input)) {

src/fs.rs

@@ -132,7 +132,7 @@ pub struct Manifest {
     pub manifest_path: PathBuf,
 
     #[serde(skip_deserializing)]
-    location_trie: arca::path::Trie<PackageLocator>,
+    location_trie: util::Trie<PackageLocator>,
 
     enable_top_level_fallback: bool,
     ignore_pattern_data: Option<RegexDef>,
@@ -265,7 +265,7 @@ pub fn init_pnp_manifest<P: AsRef<Path>>(manifest: &mut Manifest, p: P) {
             let package_location = manifest.manifest_dir
                 .join(info.package_location.clone());
 
-            let normalized_location = arca::path::normalize_path(
+            let normalized_location = util::normalize_path(
                 &package_location.to_string_lossy(),
             );
 
@@ -304,7 +304,7 @@ pub fn find_locator<'a, P: AsRef<Path>>(manifest: &'a Manifest, path: &P) -> Opt
         .expect("Assertion failed: Provided path should be absolute");
 
     if let Some(regex) = &manifest.ignore_pattern_data {
-        if regex.0.is_match(&arca::path::normalize_path(rel_path.to_string_lossy())).unwrap() {
+        if regex.0.is_match(&util::normalize_path(rel_path.to_string_lossy())).unwrap() {
             return None
         }
     }

src/lib.rs

@@ -2,6 +2,75 @@ use fancy_regex::Regex;
 use serde::{de::Error, Deserialize, Deserializer};
 use std::borrow::Cow;
 
+use path_slash::PathBufExt;
+use std::path::{PathBuf, Path};
+
+#[derive(Debug, Default, Clone)]
+pub struct Trie<T> {
+    inner: radix_trie::Trie<String, (PathBuf, T)>,
+}
+
+impl<T> Trie<T> {
+    fn key<P: AsRef<Path>>(&self, key: &P) -> String {
+        let mut p = normalize_path(key.as_ref().to_string_lossy());
+
+        if !p.ends_with('/') {
+            p.push('/');
+        }
+
+        p
+    }
+
+    pub fn get_ancestor_value<P: AsRef<Path>>(&self, key: &P) -> Option<&T> {
+        self.inner.get_ancestor_value(&self.key(&key)).map(|t| &t.1)
+    }
+
+    pub fn insert<P: AsRef<Path>>(&mut self, key: P, value: T) -> () {
+        let k = self.key(&key);
+        let p = PathBuf::from(k.clone());
+
+        self.inner.insert(k, (p, value)).map(|t| t.1);
+    }
+}
+
+pub fn normalize_path<P: AsRef<str>>(original: P) -> String {
+    let original_str = original.as_ref();
+
+    let p = PathBuf::from(original_str);
+    let mut str = clean_path::clean(p)
+        .to_slash_lossy()
+        .to_string();
+
+    if original_str.ends_with('/') && !str.ends_with('/') {
+        str.push('/');
+    }
+
+    str
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_path() {
+        assert_eq!(normalize_path(""), ".");
+        assert_eq!(normalize_path("/"), "/");
+        assert_eq!(normalize_path("foo"), "foo");
+        assert_eq!(normalize_path("foo/bar"), "foo/bar");
+        assert_eq!(normalize_path("foo//bar"), "foo/bar");
+        assert_eq!(normalize_path("foo/./bar"), "foo/bar");
+        assert_eq!(normalize_path("foo/../bar"), "bar");
+        assert_eq!(normalize_path("foo/bar/.."), "foo");
+        assert_eq!(normalize_path("foo/../../bar"), "../bar");
+        assert_eq!(normalize_path("../foo/../../bar"), "../../bar");
+        assert_eq!(normalize_path("./foo"), "foo");
+        assert_eq!(normalize_path("../foo"), "../foo");
+        assert_eq!(normalize_path("/foo/bar"), "/foo/bar");
+        assert_eq!(normalize_path("/foo/bar/"), "/foo/bar/");
+    }
+}
+
 fn strip_slash_escape(str: &str) -> String {
     let mut res = String::default();
     res.reserve_exact(str.len());

src/util.rs

@@ -5,6 +5,7 @@ use byteorder::{ReadBytesExt, LittleEndian};
 use std::io::Read;
 
 use crate::fs::FileType;
+use crate::util;
 
 #[derive(Debug)]
 pub enum Compression {
@@ -36,7 +37,7 @@ where T : AsRef<[u8]> {
         };
 
         for (name, maybe_entry) in list_zip_entries(zip.storage.as_ref())? {
-            let name = arca::path::normalize_path(name);
+            let name = util::normalize_path(name);
             let segments: Vec<&str> = name.split('/').collect();
 
             for t in 1..segments.len() - 1 {