Moves the trie to a separate crate

Author: arcanis

Cargo.lock

@@ -1,21 +1,19 @@
 [package]
 name = "pnp"
-version = "0.4.5"
+version = "0.4.6"
 edition = "2021"
 license = "BSD-2-Clause"
 description = "Resolution primitives for Yarn PnP"
 homepage = "https://yarnpkg.com"
 repository = "https://github.com/yarnpkg/berry/"
 
 [dependencies]
-clean-path = "0.2.1"
+arca = "0.1.3"
 fancy-regex = "0.11.0"
 lazy_static = "1.4.0"
 lru = "0.10.0"
 miniz_oxide = "0.7.1"
-path-slash = "0.2.1"
 pathdiff = "0.2.1"
-radix_trie = "0.2.1"
 regex = "1.7.1"
 serde = { version = "1.0.152", features = ["derive"] }
 serde_json = "1.0.93"

Cargo.toml

@@ -5,8 +5,6 @@ use serde::Deserialize;
 use std::{path::{Path, PathBuf}, fs, io::{BufReader, Read}, collections::{HashSet, HashMap}, str::Utf8Error, num::NonZeroUsize};
 use zip::{ZipArchive, result::ZipError};
 
-use crate::util;
-
 #[derive(Clone)]
 #[derive(Debug)]
 #[derive(Deserialize)]
@@ -78,7 +76,7 @@ impl Zip {
         for i in 0..zip.archive.len() {
             let entry = zip.archive.by_index_raw(i)?;
 
-            let name = util::normalize_path(entry.name());
+            let name = arca::path::normalize_path(entry.name());
             let segments: Vec<&str> = name.split('/').collect();
 
             for t in 1..segments.len() - 1 {
@@ -219,7 +217,7 @@ pub fn vpath(p: &Path) -> Result<VPath, std::io::Error> {
         .to_string_lossy()
         .to_string();
 
-    let mut p_bytes = util::normalize_path(p_str.clone())
+    let mut p_bytes = arca::path::normalize_path(p_str.clone())
         .as_bytes().to_vec();
 
     if let Some(m) = VIRTUAL_RE.captures(&p_bytes) {
@@ -231,7 +229,7 @@ pub fn vpath(p: &Path) -> Result<VPath, std::io::Error> {
                     &subpath.as_bytes(),
                 ].concat();
 
-                p_str = util::normalize_path(io_bytes_to_str(&bytes)?);
+                p_str = arca::path::normalize_path(io_bytes_to_str(&bytes)?);
                 p_bytes = p_str.as_bytes().to_vec();    
             }
         }
@@ -263,7 +261,7 @@ pub fn vpath(p: &Path) -> Result<VPath, std::io::Error> {
             let zip_path = PathBuf::from(io_bytes_to_str(&p_bytes[0..next_char_idx])?);
 
             let sub_path = if next_char_idx + 1 < p_bytes.len() {
-                util::normalize_path(io_bytes_to_str(&p_bytes[next_char_idx + 1..])?)
+                arca::path::normalize_path(io_bytes_to_str(&p_bytes[next_char_idx + 1..])?)
             } else {
                 return Ok(VPath::Native(zip_path))
             };

src/fs.rs

@@ -3,7 +3,6 @@ mod util;
 
 use fancy_regex::Regex;
 use lazy_static::lazy_static;
-use radix_trie::Trie;
 use serde::Deserialize;
 use serde_with::{serde_as, DefaultOnNull};
 use std::{path::{Path, PathBuf}, collections::{HashSet, HashMap, hash_map::Entry}};
@@ -52,6 +51,8 @@ pub struct ResolutionConfig {
 }
 
 #[derive(Clone)]
+#[derive(Debug)]
+#[derive(Default)]
 #[derive(Deserialize)]
 pub struct PackageLocator {
     name: String,
@@ -71,7 +72,7 @@ enum PackageDependency {
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PackageInformation {
-    package_location: String,
+    package_location: PathBuf,
 
     #[serde(default)]
     discard_from_lookup: bool,
@@ -92,7 +93,7 @@ pub struct Manifest {
     pub manifest_path: PathBuf,
 
     #[serde(skip_deserializing)]
-    location_trie: Trie<String, PackageLocator>,
+    location_trie: arca::path::Trie<PackageLocator>,
 
     enable_top_level_fallback: bool,
     ignore_pattern_data: Option<RegexDef>,
@@ -202,15 +203,17 @@ pub fn init_pnp_manifest<P: AsRef<Path>>(manifest: &mut Manifest, p: P) {
 
     for (name, ranges) in manifest.package_registry_data.iter_mut() {
         for (reference, info) in ranges.iter_mut() {
-            let p = manifest.manifest_dir
+            let package_location = manifest.manifest_dir
                 .join(info.package_location.clone());
 
-            info.package_location = util::normalize_path(
-                p.to_string_lossy(),
+            let normalized_location = arca::path::normalize_path(
+                &package_location.to_string_lossy(),
             );
 
+            info.package_location = PathBuf::from(normalized_location);
+
             if !info.discard_from_lookup {
-                manifest.location_trie.insert(info.package_location.clone(), PackageLocator {
+                manifest.location_trie.insert(&info.package_location, PackageLocator {
                     name: name.clone(),
                     reference: reference.clone(),
                 });
@@ -238,16 +241,12 @@ 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(&util::normalize_path(rel_path.to_string_lossy())).unwrap() {
+        if regex.0.is_match(&arca::path::normalize_path(rel_path.to_string_lossy())).unwrap() {
             return None
         }
     }
 
-    let trie_key = util::normalize_path(
-        path.as_ref().to_string_lossy(),
-    );
-
-    manifest.location_trie.get_ancestor_value(&trie_key)
+    manifest.location_trie.get_ancestor_value(&path)
 }
 
 pub fn get_package<'a>(manifest: &'a Manifest, locator: &PackageLocator) -> Result<&'a PackageInformation, Error> {
@@ -301,7 +300,7 @@ pub fn resolve_to_unqualified_via_manifest<P: AsRef<Path>>(manifest: &Manifest,
                 PackageDependency::Alias(name, reference) => get_package(&manifest, &PackageLocator { name, reference }),
             }?;
 
-            Ok(Resolution::Package(PathBuf::from(dependency_pkg.package_location.clone()), module_path.clone()))
+            Ok(Resolution::Package(dependency_pkg.package_location.clone(), module_path.clone()))
         } else {
             return Err(Error::FailedResolution);
         }

src/lib.rs

@@ -1,45 +1,6 @@
 use fancy_regex::Regex;
-use path_slash::PathBufExt;
 use serde::{de::Error, Deserialize, Deserializer};
-use std::{borrow::Cow, path::{PathBuf}};
-
-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/");
-    }
-}
+use std::{borrow::Cow};
 
 fn strip_slash_escape(str: &str) -> String {
     let mut res = String::default();