updated wasm-pkg-tools

Daniel Macovei · Daniel Macovei · commit dab9549bab65 · 2024-11-19T14:32:19.000-06:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/src/commands/add.rs b/src/commands/add.rs
@@ -1,7 +1,6 @@
 use std::{
     fs,
     path::{Path, PathBuf},
-    sync::Arc,
 };
 
 use anyhow::{bail, Context, Result};
@@ -126,7 +125,7 @@ impl AddCommand {
 
     async fn resolve_version(
         &self,
-        client: Arc<CachingClient<FileCache>>,
+        client: CachingClient<FileCache>,
         name: &PackageRef,
     ) -> Result<String> {
         let mut resolver = DependencyResolver::new_with_client(client, None)?;
diff --git a/src/commands/new.rs b/src/commands/new.rs
@@ -4,7 +4,6 @@ use std::{
     fs,
     path::{Path, PathBuf},
     process::Command,
-    sync::Arc,
 };
 
 use anyhow::{bail, Context, Result};
@@ -526,7 +525,7 @@ world example {{
     /// `DependencyResolution` instead so we can actually resolve the dependency.
     async fn resolve_target(
         &self,
-        client: Arc<CachingClient<FileCache>>,
+        client: CachingClient<FileCache>,
         target: Option<metadata::Target>,
     ) -> Result<Option<(DependencyResolution, Option<String>)>> {
         match target {
diff --git a/src/commands/update.rs b/src/commands/update.rs
@@ -9,7 +9,6 @@ use terminal_link::Link as TerminalLink;
 use wasm_pkg_core::{
     lock::{LockFile, LockedPackageVersion},
     resolver::{DependencyResolver, RegistryPackage},
-    wit::add_packages_to_resolver,
 };
 
 use crate::{
@@ -88,7 +87,7 @@ impl UpdateCommand {
         {
             let target_deps = section.target.dependencies();
             for (name, dep) in target_deps.iter() {
-                match dep {
+                match &dep.0 {
                     wasm_pkg_core::resolver::Dependency::Package(RegistryPackage {
                         version,
                         ..
@@ -99,7 +98,7 @@ impl UpdateCommand {
                 }
             }
             for (name, dep) in section.dependencies.iter() {
-                match dep {
+                match &dep.0 {
                     wasm_pkg_core::resolver::Dependency::Package(RegistryPackage {
                         version,
                         ..
@@ -111,7 +110,7 @@ impl UpdateCommand {
             }
         }
         let mut resolver = DependencyResolver::new_with_client(client, None)?;
-        add_packages_to_resolver(&mut resolver, new_packages).await?;
+        resolver.add_packages(new_packages).await?;
         let deps = resolver.resolve().await?;
 
         let mut new_lock_file = LockFile::from_dependencies(&deps, "wkg.lock").await?;
diff --git a/src/config.rs b/src/config.rs
@@ -26,7 +26,6 @@ use parse_arg::{iter_short, match_arg};
 use semver::Version;
 use std::fmt;
 use std::str::FromStr;
-use std::sync::Arc;
 use std::{collections::BTreeMap, fmt::Display, path::PathBuf};
 use toml_edit::DocumentMut;
 use wasm_pkg_client::caching::{CachingClient, FileCache};
@@ -525,11 +524,11 @@ impl Config {
         &self,
         cache: Option<PathBuf>,
         offline: bool,
-    ) -> anyhow::Result<Arc<CachingClient<FileCache>>> {
-        Ok(Arc::new(CachingClient::new(
+    ) -> anyhow::Result<CachingClient<FileCache>> {
+        Ok(CachingClient::new(
             (!offline).then(|| Client::new(self.pkg_config.clone())),
             FileCache::new(cache_dir(cache)?).await?,
-        )))
+        ))
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -11,7 +11,6 @@ use std::{
     io::{BufRead, BufReader, Read, Seek, SeekFrom},
     path::{Path, PathBuf},
     process::{Command, Stdio},
-    sync::Arc,
     time::SystemTime,
 };
 
@@ -135,7 +134,7 @@ impl From<&str> for CargoCommand {
 ///
 /// Returns any relevant output components.
 pub async fn run_cargo_command(
-    client: Arc<CachingClient<FileCache>>,
+    client: CachingClient<FileCache>,
     config: &Config,
     metadata: &Metadata,
     packages: &[PackageComponentMetadata<'_>],
@@ -731,7 +730,7 @@ pub fn load_component_metadata<'a>(
 }
 
 async fn generate_bindings(
-    client: Arc<CachingClient<FileCache>>,
+    client: CachingClient<FileCache>,
     config: &Config,
     packages: &[PackageComponentMetadata<'_>],
 ) -> Result<HashMap<String, HashMap<String, String>>> {
@@ -778,7 +777,7 @@ async fn generate_bindings(
 }
 
 async fn create_resolution_map<'a>(
-    client: Arc<CachingClient<FileCache>>,
+    client: CachingClient<FileCache>,
     packages: &'a [PackageComponentMetadata<'_>],
     lock_file: &LockFile,
 ) -> Result<PackageResolutionMap<'a>> {
@@ -1064,7 +1063,7 @@ fn add_registry_metadata(package: &Package, bytes: &[u8], path: &Path) -> Result
 /// Publish a component for the given workspace and publish options.
 pub async fn publish(
     config: &Config,
-    client: Arc<CachingClient<FileCache>>,
+    client: CachingClient<FileCache>,
     options: &PublishOptions<'_>,
 ) -> Result<()> {
     if options.dry_run {
diff --git a/src/metadata.rs b/src/metadata.rs
@@ -12,7 +12,7 @@ use cargo_metadata::Package;
 use semver::{Version, VersionReq};
 use serde::{
     de::{self, value::MapAccessDeserializer},
-    Deserialize,
+    Deserialize, Serialize
 };
 use serde_json::from_value;
 use url::Url;
@@ -169,17 +169,17 @@ pub enum Target {
         /// [select-world]: https://docs.rs/wit-parser/latest/wit_parser/struct.Resolve.html#method.select_world
         world: Option<String>,
         /// The dependencies of the wit document being targeted.
-        dependencies: HashMap<PackageRef, Dependency>,
+        dependencies: HashMap<PackageRef, WasmDependency>,
     },
 }
 
 impl Target {
     /// Gets the dependencies of the target.
-    pub fn dependencies(&self) -> Cow<HashMap<PackageRef, Dependency>> {
+    pub fn dependencies(&self) -> Cow<HashMap<PackageRef, WasmDependency>> {
         match self {
             Self::Package { name, package, .. } => Cow::Owned(HashMap::from_iter([(
                 name.clone(),
-                Dependency::Package(package.clone()),
+                WasmDependency(Dependency::Package(package.clone())),
             )])),
             Self::Local { dependencies, .. } => Cow::Borrowed(dependencies),
         }
@@ -271,7 +271,7 @@ impl<'de> Deserialize<'de> for Target {
                     world: Option<String>,
                     registry: Option<String>,
                     path: Option<PathBuf>,
-                    dependencies: HashMap<PackageRef, Dependency>,
+                    dependencies: HashMap<PackageRef, WasmDependency>,
                 }
 
                 let entry = Entry::deserialize(MapAccessDeserializer::new(map))?;
@@ -326,6 +326,112 @@ impl<'de> Deserialize<'de> for Target {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct WasmDependency(pub Dependency);
+
+impl Serialize for WasmDependency {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match &self.0 {
+            Dependency::Package(package) => {
+                if package.name.is_none() && package.registry.is_none() {
+                    let version = package.version.to_string();
+                    version.trim_start_matches('^').serialize(serializer)
+                } else {
+                    #[derive(Serialize)]
+                    struct Entry<'a> {
+                        package: Option<&'a PackageRef>,
+                        version: &'a str,
+                        registry: Option<&'a str>,
+                    }
+
+                    Entry {
+                        package: package.name.as_ref(),
+                        version: package.version.to_string().trim_start_matches('^'),
+                        registry: package.registry.as_deref(),
+                    }
+                    .serialize(serializer)
+                }
+            }
+            Dependency::Local(path) => {
+                #[derive(Serialize)]
+                struct Entry<'a> {
+                    path: &'a PathBuf,
+                }
+
+                Entry { path }.serialize(serializer)
+            }
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for WasmDependency {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl<'de> de::Visitor<'de> for Visitor {
+            type Value = WasmDependency;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(formatter, "a string or a table")
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(WasmDependency(Dependency::Package(
+                    s.parse().map_err(de::Error::custom)?,
+                )))
+            }
+
+            fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::MapAccess<'de>,
+            {
+                #[derive(Default, Deserialize)]
+                #[serde(default, deny_unknown_fields)]
+                struct Entry {
+                    path: Option<PathBuf>,
+                    package: Option<PackageRef>,
+                    version: Option<VersionReq>,
+                    registry: Option<String>,
+                }
+
+                let entry = Entry::deserialize(MapAccessDeserializer::new(map))?;
+
+                match (entry.path, entry.package, entry.version, entry.registry) {
+                    (Some(path), None, None, None) => Ok(WasmDependency(Dependency::Local(path))),
+                    (None, name, Some(version), registry) => {
+                        Ok(WasmDependency(Dependency::Package(RegistryPackage {
+                            name,
+                            version,
+                            registry,
+                        })))
+                    }
+                    (Some(_), None, Some(_), _) => Err(de::Error::custom(
+                        "cannot specify both `path` and `version` fields in a dependency entry",
+                    )),
+                    (Some(_), None, None, Some(_)) => Err(de::Error::custom(
+                        "cannot specify both `path` and `registry` fields in a dependency entry",
+                    )),
+                    (Some(_), Some(_), _, _) => Err(de::Error::custom(
+                        "cannot specify both `path` and `package` fields in a dependency entry",
+                    )),
+                    (None, None, _, _) => Err(de::Error::missing_field("package")),
+                    (None, Some(_), None, _) => Err(de::Error::missing_field("version")),
+                }
+            }
+        }
+
+        deserializer.deserialize_any(Visitor)
+    }
+}
 /// Represents the `package.metadata.component` section in `Cargo.toml`.
 #[derive(Default, Debug, Clone, Deserialize)]
 #[serde(default, deny_unknown_fields)]
@@ -337,7 +443,7 @@ pub struct ComponentSection {
     /// The path to the WASI adapter to use.
     pub adapter: Option<PathBuf>,
     /// The dependencies of the component.
-    pub dependencies: HashMap<PackageRef, Dependency>,
+    pub dependencies: HashMap<PackageRef, WasmDependency>,
     /// The registries to use for the component.
     pub registries: HashMap<String, Url>,
     /// The configuration for bindings generation.
@@ -415,14 +521,14 @@ impl ComponentMetadata {
             }
 
             for dependency in dependencies.values_mut() {
-                if let Dependency::Local(path) = dependency {
+                if let Dependency::Local(path) = &mut dependency.0 {
                     *path = manifest_dir.join(path.as_path());
                 }
             }
         }
 
         for dependency in section.dependencies.values_mut() {
-            if let Dependency::Local(path) = dependency {
+            if let Dependency::Local(path) = &mut dependency.0 {
                 *path = manifest_dir.join(path.as_path());
             }
         }
diff --git a/src/registry.rs b/src/registry.rs
@@ -1,5 +1,5 @@
 //! Module for interacting with component registries.
-use std::{collections::HashMap, sync::Arc};
+use std::collections::HashMap;
 
 use anyhow::Result;
 use cargo_metadata::PackageId;
@@ -10,7 +10,7 @@ use wasm_pkg_client::{
 };
 use wasm_pkg_core::{
     lock::{LockFile, LockedPackage, LockedPackageVersion},
-    resolver::{DependencyResolution, DependencyResolutionMap, DependencyResolver},
+    resolver::{Dependency, DependencyResolution, DependencyResolutionMap, DependencyResolver},
 };
 
 use crate::metadata::ComponentMetadata;
@@ -31,7 +31,7 @@ impl<'a> PackageDependencyResolution<'a> {
     ///
     /// Returns `Ok(None)` if the package is not a component package.
     pub async fn new(
-        client: Arc<CachingClient<FileCache>>,
+        client: CachingClient<FileCache>,
         metadata: &'a ComponentMetadata,
         lock_file: &LockFile,
     ) -> Result<PackageDependencyResolution<'a>> {
@@ -51,7 +51,7 @@ impl<'a> PackageDependencyResolution<'a> {
     }
 
     async fn resolve_target_deps(
-        client: Arc<CachingClient<FileCache>>,
+        client: CachingClient<FileCache>,
         metadata: &ComponentMetadata,
         lock_file: &LockFile,
     ) -> Result<DependencyResolutionMap> {
@@ -63,14 +63,17 @@ impl<'a> PackageDependencyResolution<'a> {
         let mut resolver = DependencyResolver::new_with_client(client, Some(lock_file))?;
 
         for (name, dependency) in target_deps.iter() {
-            resolver.add_dependency(name, dependency).await?;
+            resolver.add_shallow_dependency(name, &dependency.0).await?;
         }
+        // for (name, dependency) in target_deps.iter() {
+        //     resolver.add_dependency(name, &dependency.0).await?;
+        // }
 
         resolver.resolve().await
     }
 
     async fn resolve_deps(
-        client: Arc<CachingClient<FileCache>>,
+        client: CachingClient<FileCache>,
         metadata: &ComponentMetadata,
         lock_file: &LockFile,
     ) -> Result<DependencyResolutionMap> {
@@ -81,7 +84,11 @@ impl<'a> PackageDependencyResolution<'a> {
         let mut resolver = DependencyResolver::new_with_client(client, Some(lock_file))?;
 
         for (name, dependency) in &metadata.section.dependencies {
-            resolver.add_dependency(name, dependency).await?;
+            if let Dependency::Local(path) = dependency.clone().0 {
+                resolver.add_shallow_dependency(name, &Dependency::Local(path)).await?;
+                
+            }
+            resolver.add_dependency(name, &dependency.0).await?;
         }
 
         resolver.resolve().await
