package display impl

clippy

cleand up logging

typos ./crates --write-changes

Author: mkatychev

crates/wasm-pkg-client/src/caching/file.rs

@@ -82,7 +82,7 @@ impl Cache for FileCache {
             Error::CacheError(anyhow::anyhow!("Unable to create file for cache {e}"))
         })?;
         let mut buf =
-            StreamReader::new(data.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e)));
+            StreamReader::new(data.map_err(std::io::Error::other));
         tokio::io::copy(&mut buf, &mut file)
             .await
             .map_err(|e| Error::CacheError(e.into()))

crates/wasm-pkg-client/src/lib.rs

@@ -168,8 +168,7 @@ impl Client {
             let (mut data, p, v) = tokio::task::spawn_blocking(|| resolve_package(data))
                 .await
                 .map_err(|e| {
-                    crate::Error::IoError(std::io::Error::new(
-                        std::io::ErrorKind::Other,
+                    crate::Error::IoError(std::io::Error::other(
                         format!("Error when performing blocking IO: {e:?}"),
                     ))
                 })??;
@@ -224,7 +223,7 @@ impl Client {
                     self.config
                         .namespace_registry(package.namespace())
                         .and_then(|meta| {
-                            // If the overriden registry matches the registry we are trying to resolve, we
+                            // If the overridden registry matches the registry we are trying to resolve, we
                             // should use the metadata, otherwise we'll need to fetch the metadata from the
                             // registry
                             match (meta, is_override) {

crates/wasm-pkg-client/src/release.rs

@@ -26,7 +26,7 @@ impl Ord for VersionInfo {
 
 impl PartialOrd for VersionInfo {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.version.cmp(&other.version))
+        Some(self.cmp(other))
     }
 }
 

crates/wasm-pkg-common/src/metadata.rs

@@ -63,7 +63,7 @@ impl RegistryMetadata {
     }
 
     /// Returns an iterator of protocols configured by the registry.
-    pub fn configured_protocols(&self) -> impl Iterator<Item = Cow<str>> {
+    pub fn configured_protocols(&self) -> impl Iterator<Item = Cow<'_, str>> {
         let mut protos: BTreeSet<String> = self.protocol_configs.keys().cloned().collect();
         // Backward-compatibility aliases
         if self.oci_registry.is_some() || self.oci_namespace_prefix.is_some() {

crates/wasm-pkg-core/src/lock.rs

@@ -364,7 +364,7 @@ impl AsRef<File> for Locker {
     }
 }
 
-// NOTE(thomastaylor312): These lock file primitives from here on down are mostly copyed wholesale
+// NOTE(thomastaylor312): These lock file primitives from here on down are mostly copied wholesale
 // from the lock file implementation of cargo-component with some minor modifications to make them
 // work with tokio
 

crates/wasm-pkg-core/src/resolver.rs

@@ -38,6 +38,28 @@ pub enum Dependency {
     Local(PathBuf),
 }
 
+impl std::fmt::Display for Dependency {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Dependency::Package(RegistryPackage {
+                name,
+                version,
+                registry,
+            }) => {
+                let registry = registry.as_deref().unwrap_or("_");
+                let name = name.as_ref().map(|n| n.to_string());
+
+                write!(
+                    f,
+                    "{{ registry =  {registry} package = {}@{version} }}",
+                    name.as_deref().unwrap_or("_:_"),
+                )
+            }
+            Dependency::Local(path_buf) => write!(f, "{}", path_buf.display()),
+        }
+    }
+}
+
 impl FromStr for Dependency {
     type Err = anyhow::Error;
 
@@ -126,9 +148,9 @@ impl RegistryResolution {
             )
             .await?;
 
-        Ok(tokio_util::io::StreamReader::new(stream.map_err(|e| {
-            std::io::Error::new(std::io::ErrorKind::Other, e)
-        })))
+        Ok(tokio_util::io::StreamReader::new(
+            stream.map_err(|e| std::io::Error::other(e)),
+        ))
     }
 }
 
@@ -181,7 +203,7 @@ impl DependencyResolution {
     }
 
     /// Decodes the resolved dependency.
-    pub async fn decode(&self) -> Result<DecodedDependency> {
+    pub async fn decode(&self) -> Result<DecodedDependency<'_>> {
         // If the dependency path is a directory, assume it contains wit to parse as a package.
         let bytes = match self {
             DependencyResolution::Local(LocalResolution { path, .. })
@@ -432,7 +454,7 @@ impl<'a> DependencyResolver<'a> {
                 });
 
                 // This is a bit of a hack, but if there are multiple local dependencies that are
-                // nested and overriden, getting the packages from the local package treats _all_
+                // nested and overridden, getting the packages from the local package treats _all_
                 // deps as registry deps. So if we're handling a local path and the dependencies
                 // have a registry package already, override it. Otherwise follow normal overrides.
                 // We should definitely fix this and change where we resolve these things

crates/wasm-pkg-core/src/wit.rs

@@ -174,16 +174,16 @@ pub async fn resolve_dependencies(
     let mut resolver = DependencyResolver::new_with_client(client, lock_file)?;
     // add deps from config first in case they're local deps and then add deps from the directory
     if let Some(overrides) = config.overrides.as_ref() {
-        for (pkg, ovride) in overrides.iter() {
+        for (pkg, ovr) in overrides.iter() {
             let pkg: PackageRef = pkg.parse().context("Unable to parse as a package ref")?;
-            let dep = match (ovride.path.as_ref(), ovride.version.as_ref()) {
-                (Some(path), None) => {
-                    let path = tokio::fs::canonicalize(path).await?;
-                    Dependency::Local(path)
-                }
-                (Some(path), Some(_)) => {
-                    tracing::warn!("Ignoring version override for local package");
-                    let path = tokio::fs::canonicalize(path).await?;
+            let dep = match (ovr.path.as_ref(), ovr.version.as_ref()) {
+                (Some(path), v @ None | v @ Some(_)) => {
+                    if v.is_some() {
+                        tracing::warn!("Ignoring version override for local package");
+                    }
+                    let path = tokio::fs::canonicalize(path)
+                        .await
+                        .with_context(|| format!("{}", path.display()))?;
                     Dependency::Local(path)
                 }
                 (None, Some(version)) => Dependency::Package(RegistryPackage {
@@ -196,9 +196,11 @@ pub async fn resolve_dependencies(
                     continue;
                 }
             };
+            tracing::debug!(dependency = ?dep);
             resolver
                 .add_dependency(&pkg, &dep)
                 .await
+                .with_context(|| dep.clone())
                 .context("Unable to add dependency")?;
         }
     }

crates/wkg/src/oci.rs

@@ -171,7 +171,7 @@ impl PushArgs {
 
 fn digest_from_manifest_url(url: &str) -> &str {
     url.split('/')
-        .last()
+        .next_back()
         .expect("url did not contain manifest sha256")
 }
 

crates/wkg/tests/fixtures/wasi-http/wit/types.wit

@@ -205,7 +205,7 @@ interface types {
     /// list with the same key.
     entries: func() -> list<tuple<field-key,field-value>>;
 
-    /// Make a deep copy of the Fields. Equivelant in behavior to calling the
+    /// Make a deep copy of the Fields. Equivalent in behavior to calling the
     /// `fields` constructor on the return value of `entries`. The resulting
     /// `fields` is mutable.
     clone: func() -> fields;
@@ -310,7 +310,7 @@ interface types {
     /// `delete` operations will fail with `header-error.immutable`.
     ///
     /// This headers resource is a child: it must be dropped before the parent
-    /// `outgoing-request` is dropped, or its ownership is transfered to
+    /// `outgoing-request` is dropped, or its ownership is transferred to
     /// another component by e.g. `outgoing-handler.handle`.
     headers: func() -> headers;
   }
@@ -426,19 +426,19 @@ interface types {
     finish: static func(this: incoming-body) -> future-trailers;
   }
 
-  /// Represents a future which may eventaully return trailers, or an error.
+  /// Represents a future which may eventually return trailers, or an error.
   ///
   /// In the case that the incoming HTTP Request or Response did not have any
   /// trailers, this future will resolve to the empty set of trailers once the
   /// complete Request or Response body has been received.
   resource future-trailers {
 
     /// Returns a pollable which becomes ready when either the trailers have
-    /// been received, or an error has occured. When this pollable is ready,
+    /// been received, or an error has occurred. When this pollable is ready,
     /// the `get` method will return `some`.
     subscribe: func() -> pollable;
 
-    /// Returns the contents of the trailers, or an error which occured,
+    /// Returns the contents of the trailers, or an error which occurred,
     /// once the future is ready.
     ///
     /// The outer `option` represents future readiness. Users can wait on this
@@ -450,7 +450,7 @@ interface types {
     ///
     /// The inner `result` represents that either the HTTP Request or Response
     /// body, as well as any trailers, were received successfully, or that an
-    /// error occured receiving them. The optional `trailers` indicates whether
+    /// error occurred receiving them. The optional `trailers` indicates whether
     /// or not trailers were present in the body.
     ///
     /// When some `trailers` are returned by this method, the `trailers`
@@ -483,7 +483,7 @@ interface types {
     /// `delete` operations will fail with `header-error.immutable`.
     ///
     /// This headers resource is a child: it must be dropped before the parent
-    /// `outgoing-request` is dropped, or its ownership is transfered to
+    /// `outgoing-request` is dropped, or its ownership is transferred to
     /// another component by e.g. `outgoing-handler.handle`.
     headers: func() -> headers;
 
@@ -507,7 +507,7 @@ interface types {
   ///
   /// If the user code drops this resource, as opposed to calling the static
   /// method `finish`, the implementation should treat the body as incomplete,
-  /// and that an error has occured. The implementation should propogate this
+  /// and that an error has occurred. The implementation should propagate this
   /// error to the HTTP protocol by whatever means it has available,
   /// including: corrupting the body on the wire, aborting the associated
   /// Request, or sending a late status code for the Response.
@@ -539,14 +539,14 @@ interface types {
     ) -> result<_, error-code>;
   }
 
-  /// Represents a future which may eventaully return an incoming HTTP
+  /// Represents a future which may eventually return an incoming HTTP
   /// Response, or an error.
   ///
   /// This resource is returned by the `wasi:http/outgoing-handler` interface to
   /// provide the HTTP Response corresponding to the sent Request.
   resource future-incoming-response {
     /// Returns a pollable which becomes ready when either the Response has
-    /// been received, or an error has occured. When this pollable is ready,
+    /// been received, or an error has occurred. When this pollable is ready,
     /// the `get` method will return `some`.
     subscribe: func() -> pollable;
 
@@ -560,8 +560,8 @@ interface types {
     /// is `some`, and error on subsequent calls.
     ///
     /// The inner `result` represents that either the incoming HTTP Response
-    /// status and headers have recieved successfully, or that an error
-    /// occured. Errors may also occur while consuming the response body,
+    /// status and headers have received successfully, or that an error
+    /// occurred. Errors may also occur while consuming the response body,
     /// but those will be reported by the `incoming-body` and its
     /// `output-stream` child.
     get: func() -> option<result<result<incoming-response, error-code>>>;