added multi pkg match arm

Author: mkatychev

Cargo.toml

@@ -55,3 +55,16 @@ url = "2.5.0"
 warg-client = "0.9.2"
 warg-crypto = "0.9.2"
 warg-protocol = "0.9.2"
+
+# https://github.com/crate-ci/typos/blob/master/docs/reference.md
+[workspace.metadata.typos.default]
+extend-ignore-re = [
+    "\\d\\w{4,}\\d",
+]
+extend-ignore-words-re = [
+    '^[a-zA-Z]{1,3}$' # ignore words up to length 3
+]
+
+[workspace.metadata.typos.default.extend-words]
+# strategy shorthand
+strat = "strat"

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

@@ -45,7 +45,6 @@ pub use publisher::PackagePublisher;
 use tokio::io::AsyncSeekExt;
 use tokio::sync::RwLock;
 use tokio_util::io::SyncIoBridge;
-use wasm_pkg_common::config::RegistryConfig;
 use wasm_pkg_common::metadata::{LOCAL_PROTOCOL, OCI_PROTOCOL, WARG_PROTOCOL};
 pub use wasm_pkg_common::{
     config::{Config, CustomConfig, RegistryMapping},

crates/wasm-pkg-client/src/overlay/mod.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, io::Cursor};
+use std::collections::HashMap;
 
 use async_trait::async_trait;
 use tempfile::TempDir;

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

@@ -1,10 +1,4 @@
-use std::collections::{BTreeSet, HashMap};
 
-use petgraph::{
-    acyclic::Acyclic,
-    graph::{DiGraph, NodeIndex},
-};
-use wasm_pkg_common::registry::{DependencyGraph, DependencyOf};
 
 use crate::{PackageRef, PublishingSource, Version};
 

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

@@ -57,7 +57,7 @@ impl TryFrom<String> for Registry {
     }
 }
 
-/// Represents a directed edge in a package dependnecy graph.
+/// Represents a directed edge in a package dependency graph.
 #[derive(Clone, Debug)]
 pub struct DependencyOf;
 

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

@@ -13,9 +13,8 @@ use anyhow::{bail, Context, Result};
 use futures_util::TryStreamExt;
 use indexmap::{IndexMap, IndexSet};
 use petgraph::{
-    acyclic::{Acyclic, AcyclicEdgeError},
+    acyclic::Acyclic,
     graph::{DiGraph, NodeIndex},
-    Graph,
 };
 use semver::{Comparator, Op, Version, VersionReq};
 use tokio::io::{AsyncRead, AsyncReadExt};
@@ -882,7 +881,7 @@ pub struct PublishPlan {
 
 impl PublishPlan {
     /// Generate [`Self`] from a list of WIT package paths (files or directories).
-    fn from_paths(paths: &[impl AsRef<Path>]) -> Result<Self> {
+    pub fn from_paths(paths: &[impl AsRef<Path>]) -> Result<Self> {
         let (graph, indices) = get_local_dependencies(paths)?;
         let mut dependents = graph.into_inner();
         dependents.reverse();
@@ -895,22 +894,22 @@ impl PublishPlan {
         })
     }
 
-    fn iter<'a>(&'a self) -> impl Iterator<Item = &'a PackageRef> + 'a {
+    pub fn iter<'a>(&'a self) -> impl Iterator<Item = &'a PackageRef> + 'a {
         self.indices.iter().map(|(pkg, _)| pkg)
     }
 
-    fn is_empty(&self) -> bool {
+    pub fn is_empty(&self) -> bool {
         self.indices.is_empty()
     }
 
-    fn len(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.indices.len()
     }
 
     /// Returns the set of packages that are ready for publishing (i.e. have no outstanding dependencies).
     ///
     /// These will not be returned in future calls.
-    fn take_ready(&mut self) -> BTreeSet<PackageRef> {
+    pub fn take_ready(&mut self) -> BTreeSet<PackageRef> {
         self.dependents
             .nodes_iter()
             // there are no dependents on `self.dendents[id]`
@@ -925,7 +924,7 @@ impl PublishPlan {
 
     /// Packages confirmed to be available in the registry, potentially allowing additional
     /// packages to be "ready".
-    fn mark_confirmed(&mut self, published: impl IntoIterator<Item = PackageRef>) {
+    pub fn mark_confirmed(&mut self, published: impl IntoIterator<Item = PackageRef>) {
         for pkg in published {
             let id = self
                 .indices
@@ -943,7 +942,7 @@ impl PublishPlan {
 /// e.g. "foo:a@0.1.0, bar:b@0.2.0, and baz:c@0.3.0".
 ///
 /// Note: the final separator (e.g. "and" in the previous example) can be chosen.
-fn package_list(pkgs: impl IntoIterator<Item = PackageRef>, final_sep: &str) -> String {
+pub fn package_list(pkgs: impl IntoIterator<Item = PackageRef>, final_sep: &str) -> String {
     let mut names: Vec<_> = pkgs.into_iter().map(|pkg| pkg.to_string()).collect();
     names.sort();
 

crates/wkg/src/main.rs

@@ -15,7 +15,7 @@ use wasm_pkg_common::{
     package::PackageSpec,
     registry::Registry,
 };
-use wasm_pkg_core::lock::LockFile;
+use wasm_pkg_core::{lock::LockFile, resolver::PublishPlan};
 use wit_component::DecodedWasm;
 
 mod oci;
@@ -255,6 +255,9 @@ impl PublishArgs {
         let client = self.common.get_client().await?;
 
         let package = match self.package {
+            Some(_) if self.paths.len() > 2 => {
+                anyhow::bail!("`--package` is currently unsupported when providing more than one path argument");
+            }
             Some(PackageSpec {
                 package,
                 version: Some(v),
@@ -265,14 +268,26 @@ impl PublishArgs {
             None => None,
         };
 
+        let path = match &self.paths[..] {
+            [path] => path,
+            paths => {
+                let plan = PublishPlan::from_paths(paths)?;
+
+                for pkg in plan.iter() {
+                    println!("{pkg}");
+                }
+                todo!();
+            }
+        };
+
         // If the input is a directory, build a WIT package from it into a temp
         // file first. _tmp is held until the publish completes so the file
         // isn't deleted out from under us.
-        let (publish_path, _tmp) = if self.path.is_dir() {
+        let (publish_path, _tmp) = if path.is_dir() {
             let mut lock_file = LockFile::load(true).await?;
             let prev_lock_ref = (lock_file.version, lock_file.packages.clone());
             let (pkg_ref, _, bytes) =
-                wit::build_wit_dir(&self.path, client.clone(), &mut lock_file).await?;
+                wit::build_wit_dir(&path.clone(), client.clone(), &mut lock_file).await?;
             // There is no way to check if we are in a git repository unlike `cargo publish --allow-dirty` so
             // check against previous values.
             if lock_file != prev_lock_ref && !self.dry_run {
@@ -282,7 +297,7 @@ impl PublishArgs {
                 .with_context(|| {
                     format!(
                         "Run `wkg wit build {}` before attempting to publish",
-                        self.path.to_string_lossy()
+                        path.to_string_lossy()
                     )
                 });
             }
@@ -291,7 +306,7 @@ impl PublishArgs {
 
             (tmp.path().to_path_buf(), Some(tmp))
         } else {
-            (self.path.clone(), None)
+            (path.clone(), None)
         };
 
         let (package, version) = client