Only key by Cargo.toml and Cargo.lock files of workspace members (#180)

src/cleanup.ts

@@ -4,6 +4,7 @@ import fs from "fs";
 import path from "path";
 
 import { CARGO_HOME } from "./config";
+import { exists } from "./utils";
 import { Packages } from "./workspace";
 
 export async function cleanTargetDir(targetDir: string, packages: Packages, checkTimestamp = false) {
@@ -308,12 +309,3 @@ async function rmRF(dirName: string) {
   core.debug(`deleting "${dirName}"`);
   await io.rmRF(dirName);
 }
-
-async function exists(path: string) {
-  try {
-    await fs.promises.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}

src/config.ts

@@ -8,7 +8,7 @@ import path from "path";
 import * as toml from "smol-toml";
 
 import { getCargoBins } from "./cleanup";
-import { CacheProvider, getCmdOutput } from "./utils";
+import { CacheProvider, exists, getCmdOutput } from "./utils";
 import { Workspace } from "./workspace";
 
 const HOME = os.homedir();
@@ -142,7 +142,9 @@ export class CacheConfig {
         )),
       );
 
-      const cargo_manifests = sort_and_uniq(await globFiles(`${root}/**/Cargo.toml`));
+      const workspaceMembers = await workspace.getWorkspaceMembers();
+
+      const cargo_manifests = sort_and_uniq(workspaceMembers.map(member => path.join(member.path, "Cargo.toml")));
 
       for (const cargo_manifest of cargo_manifests) {
         try {
@@ -189,9 +191,8 @@ export class CacheConfig {
         }
       }
 
-      const cargo_locks = sort_and_uniq(await globFiles(`${root}/**/Cargo.lock`));
-
-      for (const cargo_lock of cargo_locks) {
+      const cargo_lock = path.join(workspace.root, "Cargo.lock");
+      if (await exists(cargo_lock)) {
         try {
           const content = await fs_promises.readFile(cargo_lock, { encoding: "utf8" });
           const parsed = toml.parse(content);

src/save.ts

@@ -36,7 +36,7 @@ async function run() {
 
     const allPackages = [];
     for (const workspace of config.workspaces) {
-      const packages = await workspace.getPackages();
+      const packages = await workspace.getPackagesOutsideWorkspaceRoot();
       allPackages.push(...packages);
       try {
         core.info(`... Cleaning ${workspace.target} ...`);

src/utils.ts

@@ -2,6 +2,7 @@ import * as core from "@actions/core";
 import * as exec from "@actions/exec";
 import * as buildjetCache from "@actions/buildjet-cache";
 import * as ghCache from "@actions/cache";
+import fs from "fs";
 
 export function reportError(e: any) {
   const { commandFailed } = e;
@@ -61,3 +62,12 @@ export function getCacheProvider(): CacheProvider {
     cache: cache,
   };
 }
+
+export async function exists(path: string) {
+  try {
+    await fs.promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}

src/workspace.ts

@@ -8,26 +8,33 @@ const SAVE_TARGETS = new Set(["lib", "proc-macro"]);
 export class Workspace {
   constructor(public root: string, public target: string) {}
 
-  public async getPackages(): Promise<Packages> {
+  async getPackages(filter: ((p: Meta['packages'][0]) => boolean), ...extraArgs: string[]): Promise<Packages> {
     let packages: Packages = [];
     try {
       core.debug(`collecting metadata for "${this.root}"`);
       const meta: Meta = JSON.parse(
-        await getCmdOutput("cargo", ["metadata", "--all-features", "--format-version", "1"], {
+        await getCmdOutput("cargo", ["metadata", "--all-features", "--format-version", "1", ...extraArgs], {
           cwd: this.root,
         }),
       );
       core.debug(`workspace "${this.root}" has ${meta.packages.length} packages`);
-      for (const pkg of meta.packages) {
-        if (pkg.manifest_path.startsWith(this.root)) {
-          continue;
-        }
+      for (const pkg of meta.packages.filter(filter)) {
         const targets = pkg.targets.filter((t) => t.kind.some((kind) => SAVE_TARGETS.has(kind))).map((t) => t.name);
         packages.push({ name: pkg.name, version: pkg.version, targets, path: path.dirname(pkg.manifest_path) });
       }
-    } catch {}
+    } catch (err) {
+      console.error(err);
+    }
     return packages;
   }
+
+  public async getPackagesOutsideWorkspaceRoot(): Promise<Packages> {
+    return await this.getPackages(pkg => !pkg.manifest_path.startsWith(this.root));
+  }
+
+  public async getWorkspaceMembers(): Promise<Packages> {
+    return await this.getPackages(_ => true, "--no-deps");
+  }
 }
 
 export interface PackageDefinition {