added take_ready test case

Author: mkatychev

Cargo.lock

@@ -95,6 +95,12 @@ impl PackageSpec {
     }
 }
 
+impl PartialEq<str> for PackageSpec {
+    fn eq(&self, other: &str) -> bool {
+        &format!("{self}") == other
+    }
+}
+
 impl FromStr for PackageSpec {
     type Err = Error;
 

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

@@ -43,3 +43,4 @@ features = [
 tempfile = { workspace = true }
 sha2 = { workspace = true }
 rstest = "0.23"
+glob = "0.3.3"

crates/wasm-pkg-core/Cargo.toml

@@ -885,12 +885,20 @@ impl PublishPlan {
 
             if neighbors.peek().is_none() {
                 // tracing::debug!("{dep} has no dependents");
-                println!("{dep} has no dependents");
+                println!("[{dep} has no dependents]");
+            } else {
+                println!("[{dep}]");
             }
 
             while let Some(id) = neighbors.next() {
                 let pkg = &self.dependents[id];
-                println!("{dep} -(DependencyOF)-> {pkg}");
+                let separator = if neighbors.peek().is_some() {
+                    "├─"
+                } else {
+                    "╰─"
+                };
+
+                println!("{separator}(DependencyOf)─▶ {pkg}");
             }
 
             dep
@@ -912,12 +920,13 @@ impl PublishPlan {
         self.dependents
             .nodes_iter()
             // there are no dependents on `self.dendents[id]`
-            .filter(|id| self.dependents.neighbors(*id).count() == 0)
-            .map(|id| {
-                let pkg = &self.dependents[id];
-                self.indices.remove(&pkg.package);
-                pkg.clone()
+            .filter(|id| {
+                self.dependents
+                    .neighbors_directed(*id, Direction::Incoming)
+                    .count()
+                    == 0
             })
+            .map(|id| self.dependents[id].clone())
             .collect()
     }
 
@@ -928,15 +937,37 @@ impl PublishPlan {
 
     /// Packages confirmed to be available in the registry, potentially allowing additional
     /// packages to be "ready".
-    pub fn mark_confirmed(&mut self, published: impl IntoIterator<Item = PackageRef>) {
-        for pkg in published {
+    pub fn mark_confirmed(&mut self, published: impl IntoIterator<Item = PackageSpec>) {
+        for spec in published {
             let (id, _) = self
                 .indices
-                .remove(&pkg)
+                .remove(&spec.package)
                 .expect("PackageSpec has no associated index");
-            self.dependents
-                .remove_node(id)
-                .expect("index has no associated PackageSpec");
+            // NOTE: nodes without edges will return None here
+            self.dependents.remove_node(id);
+        }
+    }
+}
+
+/// Format a collection of packages as a list
+///
+/// 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.
+pub fn package_list<'a>(
+    pkgs: impl IntoIterator<Item = &'a PackageSpec>,
+    final_sep: Option<&str>,
+) -> String {
+    let final_sep = final_sep.unwrap_or("and");
+    let mut names: Vec<_> = pkgs.into_iter().map(|pkg| pkg.to_string()).collect();
+    names.sort();
+
+    match &names[..] {
+        [] => String::new(),
+        [a] => a.clone(),
+        [a, b] => format!("{a} {final_sep} {b}"),
+        [names @ .., last] => {
+            format!("{}, {final_sep} {last}", names.join(", "))
         }
     }
 }
@@ -946,69 +977,57 @@ mod tests {
     use std::collections::HashSet;
     use std::path::PathBuf;
 
-    use super::PublishPlan;
+    use super::*;
+    use glob::glob;
     use wasm_pkg_client::PackageRef;
 
     fn transitive_local_paths() -> Vec<PathBuf> {
-        let fixtures =
-            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/transitive-local");
-        ["example-a", "example-b", "example-c"]
+        let fixtures = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("tests/fixtures/transitive-local/*/wit/");
+        glob(fixtures.to_str().unwrap())
+            .unwrap()
             .into_iter()
-            .map(|name| fixtures.join(name).join("wit"))
+            .map(|p| p.expect("glob path error"))
             .collect()
     }
 
     #[test]
-    fn publish_plan_from_paths_collects_all_packages() {
+    fn publish_plan_iter() {
         let paths = transitive_local_paths();
-        let plan = PublishPlan::from_paths(&paths).expect("plan should build");
-
-        assert!(!plan.is_empty());
-        assert_eq!(plan.len(), 3);
-
-        for name in ["example-a:foo", "example-b:bar", "example-c:baz"] {
-            let pkg: PackageRef = name.parse().expect("valid package ref");
-            assert!(
-                plan.get_path(&pkg).is_some(),
-                "expected `{name}` to have an associated path in the plan",
-            );
-        }
+        let plan = PublishPlan::from_paths(&paths).unwrap();
+        assert_eq!(
+            plan.iter().count(),
+            4,
+            "unexpected package count\npackages found: {}",
+            package_list(plan.iter(), None)
+        );
     }
 
     #[test]
-    fn publish_plan_iter_yields_each_package_once() {
+    fn publish_plan_chunks() {
         let paths = transitive_local_paths();
-        let plan = PublishPlan::from_paths(&paths).expect("plan should build");
-
-        let seen: Vec<PackageRef> = plan.iter().map(|spec| spec.package.clone()).collect();
-        assert_eq!(seen.len(), 3, "iter should yield one entry per package");
-
-        let unique: HashSet<_> = seen.iter().cloned().collect();
-        assert_eq!(unique.len(), seen.len(), "iter must not yield duplicates");
-
-        let expected: HashSet<PackageRef> = ["example-a:foo", "example-b:bar", "example-c:baz"]
-            .into_iter()
-            .map(|s| s.parse().unwrap())
-            .collect();
-        assert_eq!(unique, expected);
-    }
-}
-
-/// Format a collection of packages as a list
-///
-/// 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.
-pub fn package_list(pkgs: impl IntoIterator<Item = PackageSpec>, final_sep: &str) -> String {
-    let mut names: Vec<_> = pkgs.into_iter().map(|pkg| pkg.to_string()).collect();
-    names.sort();
-
-    match &names[..] {
-        [] => String::new(),
-        [a] => a.clone(),
-        [a, b] => format!("{a} {final_sep} {b}"),
-        [names @ .., last] => {
-            format!("{}, {final_sep} {last}", names.join(", "))
-        }
+        let mut plan = PublishPlan::from_paths(&paths).unwrap();
+        let mut ready_for_publish = plan.take_ready();
+        assert_eq!(
+            ready_for_publish.iter().collect::<Vec<_>>(),
+            ["example-c:baz@0.1.0", "example-d:foo@0.1.0"],
+        );
+        plan.mark_confirmed(ready_for_publish.into_iter());
+
+        ready_for_publish = plan.take_ready();
+        assert_eq!(
+            ready_for_publish.iter().collect::<Vec<_>>(),
+            ["example-b:bar@0.1.0"],
+        );
+        plan.mark_confirmed(ready_for_publish.into_iter());
+
+        ready_for_publish = plan.take_ready();
+        assert_eq!(
+            ready_for_publish.iter().collect::<Vec<_>>(),
+            ["example-a:foo@0.1.0"],
+        );
+        plan.mark_confirmed(ready_for_publish.into_iter());
+
+        assert!(plan.is_empty());
     }
 }

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

@@ -204,14 +204,12 @@ pub fn get_local_dependencies(
         for (dep, _version) in deps {
             if let Some(&(dep, _)) = indices.get(&dep) {
                 let (pkg, _) = indices[&spec.package];
-                // // dep -(DependencyOF)-> pkg
-                // graph.try_update_edge(dep, pkg, Direction::Outgoing);
-                // // pkg -(DependsOn)-> dep
+                // // pkg <=DependsOn= dep
                 graph
-                    .try_update_edge(pkg, dep, Direction::Outgoing)
+                    .try_update_edge(pkg, dep, Direction::Incoming)
                     .map_err(|e| match e {
                         petgraph::acyclic::AcyclicEdgeError::Cycle(cycle) => {
-                            anyhow::anyhow!("cyclical depndency detected")
+                            anyhow::anyhow!("cyclical dependency detected")
                                 .context(format!("package {}", graph[cycle.node_id()]))
                                 .context(format!("package {}", graph[pkg]))
                         }

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

@@ -0,0 +1,5 @@
+package example-d:foo@0.1.0;
+
+interface bar {
+    type baz = string;
+}