pubm 0.2.5 → 0.2.7

package/bin/cli.js

@@ -5521,6 +5521,31 @@ var RustEcosystem = class extends Ecosystem {
     pkg.version = newVersion;
     await writeFile(filePath, stringify(cargo));
   }
+  /**
+   * Update the `version` field of dependencies that match sibling crate names.
+   * This ensures `cargo publish` works when crates depend on each other via path.
+   */
+  async updateSiblingDependencyVersions(siblingVersions) {
+    const filePath = path8.join(this.packagePath, "Cargo.toml");
+    const raw = await readFile(filePath, "utf-8");
+    const cargo = parse(raw);
+    let modified = false;
+    for (const section of ["dependencies", "build-dependencies"]) {
+      const sectionData = cargo[section];
+      if (!sectionData) continue;
+      for (const [depName, depValue] of Object.entries(sectionData)) {
+        if (typeof depValue === "object" && depValue !== null && "path" in depValue && siblingVersions.has(depName)) {
+          const dep = depValue;
+          dep.version = siblingVersions.get(depName);
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      await writeFile(filePath, stringify(cargo));
+    }
+    return modified;
+  }
   async syncLockfile() {
     const lockfilePath = await this.findLockfile();
     if (!lockfilePath) return void 0;
@@ -5839,8 +5864,15 @@ async function replaceVersion(version2, packages) {
         );
       }
       return "jsr.json";
-    })(),
-    ...(packages ?? []).filter((pkg) => pkg.registries.includes("crates")).map(async (pkg) => {
+    })()
+  ]);
+  const cratePackages = (packages ?? []).filter(
+    (pkg) => pkg.registries.includes("crates")
+  );
+  const crateFiles = [];
+  if (cratePackages.length > 0) {
+    const ecosystems = [];
+    for (const pkg of cratePackages) {
       const eco = new RustEcosystem(path9.resolve(pkg.path));
       try {
         await eco.writeVersion(version2);
@@ -5850,19 +5882,38 @@ async function replaceVersion(version2, packages) {
           { cause: error }
         );
       }
-      let lockfilePath;
+      ecosystems.push({ eco, pkg });
+    }
+    if (ecosystems.length > 1) {
+      const siblingVersions = /* @__PURE__ */ new Map();
+      for (const { eco } of ecosystems) {
+        siblingVersions.set(await eco.packageName(), version2);
+      }
+      await Promise.all(
+        ecosystems.map(
+          ({ eco }) => eco.updateSiblingDependencyVersions(siblingVersions)
+        )
+      );
+    }
+    for (const { eco, pkg } of ecosystems) {
+      crateFiles.push(path9.join(pkg.path, "Cargo.toml"));
       try {
-        lockfilePath = await eco.syncLockfile();
+        const lockfilePath = await eco.syncLockfile();
+        if (lockfilePath) crateFiles.push(lockfilePath);
       } catch (error) {
         throw new AbstractError(
           `Failed to sync Cargo.lock at ${pkg.path}: ${error instanceof Error ? error.message : error}`,
           { cause: error }
         );
       }
-      return [path9.join(pkg.path, "Cargo.toml"), lockfilePath];
-    })
-  ]);
-  return [...new Set(results.flat().filter((v) => !!v))];
+    }
+  }
+  const allFiles = [];
+  for (const r of results) {
+    if (r) allFiles.push(r);
+  }
+  allFiles.push(...crateFiles);
+  return [...new Set(allFiles)];
 }
 
 // src/utils/package-manager.ts
@@ -5993,7 +6044,7 @@ ${stderr}` : "Failed to run `cargo publish`";
   }
   async dryRunPublish(manifestDir) {
     try {
-      const args = ["publish", "--dry-run"];
+      const args = ["publish", "--dry-run", "--no-verify"];
       if (manifestDir) {
         args.push("--manifest-path", path10.join(manifestDir, "Cargo.toml"));
       }
@@ -7673,7 +7724,7 @@ async function run(options) {
           }
         },
         {
-          skip: (ctx2) => options.skipPublish || !!ctx2.preview || options.preflight,
+          skip: (ctx2) => !!options.skipPublish || !!ctx2.preview || !!options.preflight,
           title: "Publishing",
           task: async (ctx2, parentTask) => parentTask.newListr(await collectPublishTasks(ctx2), {
             concurrent: true
@@ -7699,7 +7750,7 @@ async function run(options) {
           }
         },
         {
-          skip: (ctx2) => options.skipReleaseDraft || !!ctx2.preview,
+          skip: (ctx2) => !!options.skipReleaseDraft || !!ctx2.preview,
           title: "Creating release draft on GitHub",
           task: async (ctx2, task) => {
             const git = new Git();

package/dist/index.cjs

@@ -4861,6 +4861,31 @@ var RustEcosystem = class extends Ecosystem {
     pkg.version = newVersion;
     await (0, import_promises2.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
   }
+  /**
+   * Update the `version` field of dependencies that match sibling crate names.
+   * This ensures `cargo publish` works when crates depend on each other via path.
+   */
+  async updateSiblingDependencyVersions(siblingVersions) {
+    const filePath = import_node_path2.default.join(this.packagePath, "Cargo.toml");
+    const raw = await (0, import_promises2.readFile)(filePath, "utf-8");
+    const cargo = (0, import_smol_toml.parse)(raw);
+    let modified = false;
+    for (const section of ["dependencies", "build-dependencies"]) {
+      const sectionData = cargo[section];
+      if (!sectionData) continue;
+      for (const [depName, depValue] of Object.entries(sectionData)) {
+        if (typeof depValue === "object" && depValue !== null && "path" in depValue && siblingVersions.has(depName)) {
+          const dep = depValue;
+          dep.version = siblingVersions.get(depName);
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      await (0, import_promises2.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
+    }
+    return modified;
+  }
   async syncLockfile() {
     const lockfilePath = await this.findLockfile();
     if (!lockfilePath) return void 0;
@@ -5179,8 +5204,15 @@ async function replaceVersion(version2, packages) {
         );
       }
       return "jsr.json";
-    })(),
-    ...(packages ?? []).filter((pkg) => pkg.registries.includes("crates")).map(async (pkg) => {
+    })()
+  ]);
+  const cratePackages = (packages ?? []).filter(
+    (pkg) => pkg.registries.includes("crates")
+  );
+  const crateFiles = [];
+  if (cratePackages.length > 0) {
+    const ecosystems = [];
+    for (const pkg of cratePackages) {
       const eco = new RustEcosystem(import_node_path3.default.resolve(pkg.path));
       try {
         await eco.writeVersion(version2);
@@ -5190,19 +5222,38 @@ async function replaceVersion(version2, packages) {
           { cause: error }
         );
       }
-      let lockfilePath;
+      ecosystems.push({ eco, pkg });
+    }
+    if (ecosystems.length > 1) {
+      const siblingVersions = /* @__PURE__ */ new Map();
+      for (const { eco } of ecosystems) {
+        siblingVersions.set(await eco.packageName(), version2);
+      }
+      await Promise.all(
+        ecosystems.map(
+          ({ eco }) => eco.updateSiblingDependencyVersions(siblingVersions)
+        )
+      );
+    }
+    for (const { eco, pkg } of ecosystems) {
+      crateFiles.push(import_node_path3.default.join(pkg.path, "Cargo.toml"));
       try {
-        lockfilePath = await eco.syncLockfile();
+        const lockfilePath = await eco.syncLockfile();
+        if (lockfilePath) crateFiles.push(lockfilePath);
       } catch (error) {
         throw new AbstractError(
           `Failed to sync Cargo.lock at ${pkg.path}: ${error instanceof Error ? error.message : error}`,
           { cause: error }
         );
       }
-      return [import_node_path3.default.join(pkg.path, "Cargo.toml"), lockfilePath];
-    })
-  ]);
-  return [...new Set(results.flat().filter((v) => !!v))];
+    }
+  }
+  const allFiles = [];
+  for (const r of results) {
+    if (r) allFiles.push(r);
+  }
+  allFiles.push(...crateFiles);
+  return [...new Set(allFiles)];
 }
 
 // src/utils/package-manager.ts
@@ -5456,7 +5507,7 @@ ${stderr}` : "Failed to run `cargo publish`";
   }
   async dryRunPublish(manifestDir) {
     try {
-      const args = ["publish", "--dry-run"];
+      const args = ["publish", "--dry-run", "--no-verify"];
       if (manifestDir) {
         args.push("--manifest-path", import_node_path5.default.join(manifestDir, "Cargo.toml"));
       }
@@ -7212,7 +7263,7 @@ async function run(options) {
           }
         },
         {
-          skip: (ctx2) => options.skipPublish || !!ctx2.preview || options.preflight,
+          skip: (ctx2) => !!options.skipPublish || !!ctx2.preview || !!options.preflight,
           title: "Publishing",
           task: async (ctx2, parentTask) => parentTask.newListr(await collectPublishTasks(ctx2), {
             concurrent: true
@@ -7238,7 +7289,7 @@ async function run(options) {
           }
         },
         {
-          skip: (ctx2) => options.skipReleaseDraft || !!ctx2.preview,
+          skip: (ctx2) => !!options.skipReleaseDraft || !!ctx2.preview,
           title: "Creating release draft on GitHub",
           task: async (ctx2, task) => {
             const git = new Git();

package/dist/index.js

@@ -4828,6 +4828,31 @@ var RustEcosystem = class extends Ecosystem {
     pkg.version = newVersion;
     await writeFile(filePath, stringify(cargo));
   }
+  /**
+   * Update the `version` field of dependencies that match sibling crate names.
+   * This ensures `cargo publish` works when crates depend on each other via path.
+   */
+  async updateSiblingDependencyVersions(siblingVersions) {
+    const filePath = path2.join(this.packagePath, "Cargo.toml");
+    const raw = await readFile(filePath, "utf-8");
+    const cargo = parse(raw);
+    let modified = false;
+    for (const section of ["dependencies", "build-dependencies"]) {
+      const sectionData = cargo[section];
+      if (!sectionData) continue;
+      for (const [depName, depValue] of Object.entries(sectionData)) {
+        if (typeof depValue === "object" && depValue !== null && "path" in depValue && siblingVersions.has(depName)) {
+          const dep = depValue;
+          dep.version = siblingVersions.get(depName);
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      await writeFile(filePath, stringify(cargo));
+    }
+    return modified;
+  }
   async syncLockfile() {
     const lockfilePath = await this.findLockfile();
     if (!lockfilePath) return void 0;
@@ -5146,8 +5171,15 @@ async function replaceVersion(version2, packages) {
         );
       }
       return "jsr.json";
-    })(),
-    ...(packages ?? []).filter((pkg) => pkg.registries.includes("crates")).map(async (pkg) => {
+    })()
+  ]);
+  const cratePackages = (packages ?? []).filter(
+    (pkg) => pkg.registries.includes("crates")
+  );
+  const crateFiles = [];
+  if (cratePackages.length > 0) {
+    const ecosystems = [];
+    for (const pkg of cratePackages) {
       const eco = new RustEcosystem(path3.resolve(pkg.path));
       try {
         await eco.writeVersion(version2);
@@ -5157,19 +5189,38 @@ async function replaceVersion(version2, packages) {
           { cause: error }
         );
       }
-      let lockfilePath;
+      ecosystems.push({ eco, pkg });
+    }
+    if (ecosystems.length > 1) {
+      const siblingVersions = /* @__PURE__ */ new Map();
+      for (const { eco } of ecosystems) {
+        siblingVersions.set(await eco.packageName(), version2);
+      }
+      await Promise.all(
+        ecosystems.map(
+          ({ eco }) => eco.updateSiblingDependencyVersions(siblingVersions)
+        )
+      );
+    }
+    for (const { eco, pkg } of ecosystems) {
+      crateFiles.push(path3.join(pkg.path, "Cargo.toml"));
       try {
-        lockfilePath = await eco.syncLockfile();
+        const lockfilePath = await eco.syncLockfile();
+        if (lockfilePath) crateFiles.push(lockfilePath);
       } catch (error) {
         throw new AbstractError(
           `Failed to sync Cargo.lock at ${pkg.path}: ${error instanceof Error ? error.message : error}`,
           { cause: error }
         );
       }
-      return [path3.join(pkg.path, "Cargo.toml"), lockfilePath];
-    })
-  ]);
-  return [...new Set(results.flat().filter((v) => !!v))];
+    }
+  }
+  const allFiles = [];
+  for (const r of results) {
+    if (r) allFiles.push(r);
+  }
+  allFiles.push(...crateFiles);
+  return [...new Set(allFiles)];
 }
 
 // src/utils/package-manager.ts
@@ -5422,7 +5473,7 @@ ${stderr}` : "Failed to run `cargo publish`";
   }
   async dryRunPublish(manifestDir) {
     try {
-      const args = ["publish", "--dry-run"];
+      const args = ["publish", "--dry-run", "--no-verify"];
       if (manifestDir) {
         args.push("--manifest-path", path5.join(manifestDir, "Cargo.toml"));
       }
@@ -7176,7 +7227,7 @@ async function run(options) {
           }
         },
         {
-          skip: (ctx2) => options.skipPublish || !!ctx2.preview || options.preflight,
+          skip: (ctx2) => !!options.skipPublish || !!ctx2.preview || !!options.preflight,
           title: "Publishing",
           task: async (ctx2, parentTask) => parentTask.newListr(await collectPublishTasks(ctx2), {
             concurrent: true
@@ -7202,7 +7253,7 @@ async function run(options) {
           }
         },
         {
-          skip: (ctx2) => options.skipReleaseDraft || !!ctx2.preview,
+          skip: (ctx2) => !!options.skipReleaseDraft || !!ctx2.preview,
           title: "Creating release draft on GitHub",
           task: async (ctx2, task) => {
             const git = new Git();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pubm",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "engines": {
     "node": ">=18",
     "git": ">=2.11.0"