as-test 1.1.6 → 1.1.8

package/bin/commands/build.js

@@ -1,32 +1,52 @@
-import { closeSerialBuildWorkerPool, } from "./build-core.js";
+import { closeSerialBuildWorkerPool } from "./build-core.js";
 export { build } from "./build-core.js";
-export { BuildFailureError, formatInvocation, getBuildInvocationPreview, getBuildReuseInfo, } from "./build-core.js";
-export async function executeBuildCommand(rawArgs, configPath, selectedModes, deps) {
-    const commandArgs = deps.resolveCommandArgs(rawArgs, "build");
-    const listFlags = deps.resolveListFlags(rawArgs, "build");
-    const featureToggles = deps.resolveFeatureToggles(rawArgs, "build");
-    const parallel = deps.resolveBuildParallelJobs(rawArgs);
-    const buildFeatureToggles = {
-        tryAs: featureToggles.tryAs,
-        coverage: featureToggles.coverage,
-    };
-    const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
-    if (listFlags.list || listFlags.listModes) {
-        await deps.listExecutionPlan("build", configPath, commandArgs, modeTargets, listFlags);
-        return;
-    }
-    const previousBuildApi = process.env.AS_TEST_BUILD_API;
-    process.env.AS_TEST_BUILD_API = "1";
-    try {
-        await deps.runBuildModes(configPath, commandArgs, modeTargets, buildFeatureToggles, parallel);
-    }
-    finally {
-        if (previousBuildApi == undefined) {
-            delete process.env.AS_TEST_BUILD_API;
-        }
-        else {
-            process.env.AS_TEST_BUILD_API = previousBuildApi;
-        }
-        await closeSerialBuildWorkerPool();
+export {
+  BuildFailureError,
+  formatInvocation,
+  getBuildInvocationPreview,
+  getBuildReuseInfo,
+} from "./build-core.js";
+export async function executeBuildCommand(
+  rawArgs,
+  configPath,
+  selectedModes,
+  deps,
+) {
+  const commandArgs = deps.resolveCommandArgs(rawArgs, "build");
+  const listFlags = deps.resolveListFlags(rawArgs, "build");
+  const featureToggles = deps.resolveFeatureToggles(rawArgs, "build");
+  const parallel = deps.resolveBuildParallelJobs(rawArgs);
+  const buildFeatureToggles = {
+    tryAs: featureToggles.tryAs,
+    coverage: featureToggles.coverage,
+  };
+  const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
+  if (listFlags.list || listFlags.listModes) {
+    await deps.listExecutionPlan(
+      "build",
+      configPath,
+      commandArgs,
+      modeTargets,
+      listFlags,
+    );
+    return;
+  }
+  const previousBuildApi = process.env.AS_TEST_BUILD_API;
+  process.env.AS_TEST_BUILD_API = "1";
+  try {
+    await deps.runBuildModes(
+      configPath,
+      commandArgs,
+      modeTargets,
+      buildFeatureToggles,
+      parallel,
+    );
+  } finally {
+    if (previousBuildApi == undefined) {
+      delete process.env.AS_TEST_BUILD_API;
+    } else {
+      process.env.AS_TEST_BUILD_API = previousBuildApi;
     }
+    await closeSerialBuildWorkerPool();
+  }
 }

package/bin/commands/clean-core.js

@@ -3,135 +3,142 @@ import { existsSync, rmSync } from "fs";
 import * as path from "path";
 import { applyMode, loadConfig } from "../util.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
-export async function clean(configPath = DEFAULT_CONFIG_PATH, modes = [undefined], fullClean = false) {
-    const loadedConfig = loadConfig(configPath, true);
-    const targets = new Map();
-    const ownership = buildOwnershipMap(loadedConfig);
-    if (fullClean) {
-        collectRootTarget(targets, loadedConfig.outDir, "build");
-        collectRootTarget(targets, loadedConfig.fuzz.crashDir, "crashes");
-        collectRootTarget(targets, loadedConfig.coverageDir, "coverage");
-        collectRootTarget(targets, loadedConfig.logs, "logs");
-        for (const modeName of modes) {
-            const active = applyMode(loadedConfig, modeName).config;
-            collectTarget(targets, active.outDir, modeName, "build");
-            collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
-            collectTarget(targets, active.coverageDir, modeName, "coverage");
-            collectTarget(targets, active.logs, modeName, "logs");
-        }
-        pruneNestedTargets(targets);
+export async function clean(
+  configPath = DEFAULT_CONFIG_PATH,
+  modes = [undefined],
+  fullClean = false,
+) {
+  const loadedConfig = loadConfig(configPath, true);
+  const targets = new Map();
+  const ownership = buildOwnershipMap(loadedConfig);
+  if (fullClean) {
+    collectRootTarget(targets, loadedConfig.outDir, "build");
+    collectRootTarget(targets, loadedConfig.fuzz.crashDir, "crashes");
+    collectRootTarget(targets, loadedConfig.coverageDir, "coverage");
+    collectRootTarget(targets, loadedConfig.logs, "logs");
+    for (const modeName of modes) {
+      const active = applyMode(loadedConfig, modeName).config;
+      collectTarget(targets, active.outDir, modeName, "build");
+      collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
+      collectTarget(targets, active.coverageDir, modeName, "coverage");
+      collectTarget(targets, active.logs, modeName, "logs");
     }
-    else {
-        for (const modeName of modes) {
-            const active = applyMode(loadedConfig, modeName).config;
-            collectTarget(targets, active.outDir, modeName, "build");
-            collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
-            collectTarget(targets, active.coverageDir, modeName, "coverage");
-            collectTarget(targets, active.logs, modeName, "logs");
-        }
+    pruneNestedTargets(targets);
+  } else {
+    for (const modeName of modes) {
+      const active = applyMode(loadedConfig, modeName).config;
+      collectTarget(targets, active.outDir, modeName, "build");
+      collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
+      collectTarget(targets, active.coverageDir, modeName, "coverage");
+      collectTarget(targets, active.logs, modeName, "logs");
     }
-    let removed = 0;
-    for (const [targetPath, owners] of [...targets.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-        if (!fullClean) {
-            const allOwners = ownership.get(targetPath) ?? owners;
-            const unselectedOwners = allOwners.filter((owner) => !owners.includes(owner));
-            if (unselectedOwners.length) {
-                continue;
-            }
-        }
-        if (!existsSync(targetPath)) {
-            continue;
-        }
-        rmSync(targetPath, { recursive: true, force: true });
-        removed++;
-        process.stdout.write(`${chalk.bgGreenBright.black(" CLEAN ")} ${toRelativePath(targetPath)} ${chalk.dim(`(${owners.join(", ")})`)}\n`);
+  }
+  let removed = 0;
+  for (const [targetPath, owners] of [...targets.entries()].sort((a, b) =>
+    a[0].localeCompare(b[0]),
+  )) {
+    if (!fullClean) {
+      const allOwners = ownership.get(targetPath) ?? owners;
+      const unselectedOwners = allOwners.filter(
+        (owner) => !owners.includes(owner),
+      );
+      if (unselectedOwners.length) {
+        continue;
+      }
     }
-    process.stdout.write(`${chalk.bold("Summary:")} removed ${removed} path(s)\n`);
+    if (!existsSync(targetPath)) {
+      continue;
+    }
+    rmSync(targetPath, { recursive: true, force: true });
+    removed++;
+    process.stdout.write(
+      `${chalk.bgGreenBright.black(" CLEAN ")} ${toRelativePath(targetPath)} ${chalk.dim(`(${owners.join(", ")})`)}\n`,
+    );
+  }
+  process.stdout.write(
+    `${chalk.bold("Summary:")} removed ${removed} path(s)\n`,
+  );
 }
 function buildOwnershipMap(loadedConfig) {
-    const ownership = new Map();
-    const modeNames = [
-        undefined,
-        ...Object.keys(loadedConfig.modes),
-    ];
-    for (const modeName of modeNames) {
-        const active = applyMode(loadedConfig, modeName).config;
-        collectOwnership(ownership, active.outDir, modeName, "build");
-        collectOwnership(ownership, active.fuzz.crashDir, modeName, "crashes");
-        collectOwnership(ownership, active.coverageDir, modeName, "coverage");
-        collectOwnership(ownership, active.logs, modeName, "logs");
-    }
-    return ownership;
+  const ownership = new Map();
+  const modeNames = [undefined, ...Object.keys(loadedConfig.modes)];
+  for (const modeName of modeNames) {
+    const active = applyMode(loadedConfig, modeName).config;
+    collectOwnership(ownership, active.outDir, modeName, "build");
+    collectOwnership(ownership, active.fuzz.crashDir, modeName, "crashes");
+    collectOwnership(ownership, active.coverageDir, modeName, "coverage");
+    collectOwnership(ownership, active.logs, modeName, "logs");
+  }
+  return ownership;
 }
 function collectRootTarget(targets, rawPath, kind) {
-    if (!rawPath || rawPath == "none")
-        return;
-    const resolved = path.resolve(process.cwd(), rawPath);
-    ensureSafeCleanPath(resolved, rawPath, kind);
-    const owner = `all:${kind}`;
-    const existing = targets.get(resolved);
-    if (existing) {
-        if (!existing.includes(owner))
-            existing.push(owner);
-        return;
-    }
-    targets.set(resolved, [owner]);
+  if (!rawPath || rawPath == "none") return;
+  const resolved = path.resolve(process.cwd(), rawPath);
+  ensureSafeCleanPath(resolved, rawPath, kind);
+  const owner = `all:${kind}`;
+  const existing = targets.get(resolved);
+  if (existing) {
+    if (!existing.includes(owner)) existing.push(owner);
+    return;
+  }
+  targets.set(resolved, [owner]);
 }
 function collectOwnership(ownership, rawPath, modeName, kind) {
-    if (!rawPath || rawPath == "none")
-        return;
-    const resolved = path.resolve(process.cwd(), rawPath);
-    ensureSafeCleanPath(resolved, rawPath, kind);
-    const owner = `${modeName ?? "default"}:${kind}`;
-    const existing = ownership.get(resolved);
-    if (existing) {
-        if (!existing.includes(owner))
-            existing.push(owner);
-        return;
-    }
-    ownership.set(resolved, [owner]);
+  if (!rawPath || rawPath == "none") return;
+  const resolved = path.resolve(process.cwd(), rawPath);
+  ensureSafeCleanPath(resolved, rawPath, kind);
+  const owner = `${modeName ?? "default"}:${kind}`;
+  const existing = ownership.get(resolved);
+  if (existing) {
+    if (!existing.includes(owner)) existing.push(owner);
+    return;
+  }
+  ownership.set(resolved, [owner]);
 }
 function collectTarget(targets, rawPath, modeName, kind) {
-    if (!rawPath || rawPath == "none")
-        return;
-    const resolved = path.resolve(process.cwd(), rawPath);
-    ensureSafeCleanPath(resolved, rawPath, kind);
-    const owner = `${modeName ?? "default"}:${kind}`;
-    const existing = targets.get(resolved);
-    if (existing) {
-        if (!existing.includes(owner))
-            existing.push(owner);
-        return;
-    }
-    targets.set(resolved, [owner]);
+  if (!rawPath || rawPath == "none") return;
+  const resolved = path.resolve(process.cwd(), rawPath);
+  ensureSafeCleanPath(resolved, rawPath, kind);
+  const owner = `${modeName ?? "default"}:${kind}`;
+  const existing = targets.get(resolved);
+  if (existing) {
+    if (!existing.includes(owner)) existing.push(owner);
+    return;
+  }
+  targets.set(resolved, [owner]);
 }
 function pruneNestedTargets(targets) {
-    const paths = [...targets.keys()].sort((a, b) => a.length - b.length);
-    for (const targetPath of paths) {
-        for (const otherPath of paths) {
-            if (targetPath == otherPath)
-                continue;
-            const relative = path.relative(targetPath, otherPath);
-            if (!relative.length ||
-                relative == ".." ||
-                relative.startsWith(`..${path.sep}`)) {
-                continue;
-            }
-            targets.delete(otherPath);
-        }
+  const paths = [...targets.keys()].sort((a, b) => a.length - b.length);
+  for (const targetPath of paths) {
+    for (const otherPath of paths) {
+      if (targetPath == otherPath) continue;
+      const relative = path.relative(targetPath, otherPath);
+      if (
+        !relative.length ||
+        relative == ".." ||
+        relative.startsWith(`..${path.sep}`)
+      ) {
+        continue;
+      }
+      targets.delete(otherPath);
     }
+  }
 }
 function ensureSafeCleanPath(resolvedPath, rawPath, kind) {
-    const cwd = path.resolve(process.cwd());
-    const relative = path.relative(cwd, resolvedPath);
-    if (!relative.length ||
-        relative == ".." ||
-        relative.startsWith(`..${path.sep}`) ||
-        path.parse(resolvedPath).root == resolvedPath) {
-        throw new Error(`refusing to clean unsafe ${kind} path "${rawPath}" (${resolvedPath})`);
-    }
+  const cwd = path.resolve(process.cwd());
+  const relative = path.relative(cwd, resolvedPath);
+  if (
+    !relative.length ||
+    relative == ".." ||
+    relative.startsWith(`..${path.sep}`) ||
+    path.parse(resolvedPath).root == resolvedPath
+  ) {
+    throw new Error(
+      `refusing to clean unsafe ${kind} path "${rawPath}" (${resolvedPath})`,
+    );
+  }
 }
 function toRelativePath(targetPath) {
-    const relative = path.relative(process.cwd(), targetPath);
-    return relative.length ? relative : ".";
+  const relative = path.relative(process.cwd(), targetPath);
+  return relative.length ? relative : ".";
 }

package/bin/commands/clean.js

@@ -1,14 +1,20 @@
 import { clean } from "./clean-core.js";
 import { loadConfig } from "../util.js";
 export { clean } from "./clean-core.js";
-export async function executeCleanCommand(rawArgs, configPath, selectedModes, resolveExecutionModes) {
-    const modeTargets = selectedModes.length > 0
-        ? resolveExecutionModes(configPath, selectedModes)
-        : resolveAllCleanModes(configPath);
-    await clean(configPath, modeTargets, selectedModes.length == 0);
+export async function executeCleanCommand(
+  rawArgs,
+  configPath,
+  selectedModes,
+  resolveExecutionModes,
+) {
+  const modeTargets =
+    selectedModes.length > 0
+      ? resolveExecutionModes(configPath, selectedModes)
+      : resolveAllCleanModes(configPath);
+  await clean(configPath, modeTargets, selectedModes.length == 0);
 }
 function resolveAllCleanModes(configPath) {
-    const resolvedConfigPath = configPath ?? "./as-test.config.json";
-    const config = loadConfig(resolvedConfigPath, true);
-    return [undefined, ...Object.keys(config.modes)];
+  const resolvedConfigPath = configPath ?? "./as-test.config.json";
+  const config = loadConfig(resolvedConfigPath, true);
+  return [undefined, ...Object.keys(config.modes)];
 }