suppress logs in tests

Author: mbostock

src/build.ts

@@ -71,7 +71,7 @@ export async function build(context: CommandContext = makeCommandContext()) {
         continue;
       }
       if (verbose) process.stdout.write(`generate ${loader.path} → `);
-      sourcePath = join(sourceRoot, await loader.load());
+      sourcePath = join(sourceRoot, await loader.load({verbose}));
       if (verbose) console.log(sourcePath);
     }
     if (verbose) console.log("copy", sourcePath, "→", outputPath);

src/dataloader.ts

@@ -1,5 +1,5 @@
 import {spawn} from "node:child_process";
-import {existsSync} from "node:fs";
+import {existsSync, statSync} from "node:fs";
 import {mkdir, open, rename, unlink} from "node:fs/promises";
 import {dirname, join} from "node:path";
 import {maybeStat, prepareOutput} from "./files.js";
@@ -71,58 +71,71 @@ export class Loader {
    * to the source root; this is within the .observablehq/cache folder within
    * the source root.
    */
-  async load(): Promise<string> {
+  async load({verbose = true}: {verbose?: boolean} = {}): Promise<string> {
     let command = runningCommands.get(this.path);
-    if (command) return command;
-    command = (async () => {
+    if (!command) {
+      command = (async () => {
+        const outputPath = join(".observablehq", "cache", this.targetPath);
+        const cachePath = join(this.sourceRoot, outputPath);
+        const loaderStat = await maybeStat(this.path);
+        const cacheStat = await maybeStat(cachePath);
+        if (cacheStat && cacheStat.mtimeMs > loaderStat!.mtimeMs) return outputPath;
+        const tempPath = join(this.sourceRoot, ".observablehq", "cache", `${this.targetPath}.${process.pid}`);
+        await prepareOutput(tempPath);
+        const tempFd = await open(tempPath, "w");
+        const tempFileStream = tempFd.createWriteStream({highWaterMark: 1024 * 1024});
+        const subprocess = spawn(this.command, this.args, {windowsHide: true, stdio: ["ignore", "pipe", "inherit"]});
+        subprocess.stdout.pipe(tempFileStream);
+        const code = await new Promise((resolve, reject) => {
+          subprocess.on("error", reject);
+          subprocess.on("close", resolve);
+        });
+        await tempFd.close();
+        if (code === 0) {
+          await mkdir(dirname(cachePath), {recursive: true});
+          await rename(tempPath, cachePath);
+        } else {
+          await unlink(tempPath);
+          throw new Error(`loader exited with code ${code}`);
+        }
+        return outputPath;
+      })();
+      command.finally(() => runningCommands.delete(this.path)).catch(() => {});
+      runningCommands.set(this.path, command);
+    }
+    if (verbose) {
       console.info(`${this.path} start`);
-      const time = performance.now();
-      const outputPath = join(".observablehq", "cache", this.targetPath);
-      const cachePath = join(this.sourceRoot, outputPath);
-      const loaderStat = await maybeStat(this.path);
-      const cacheStat = await maybeStat(cachePath);
-      if (cacheStat && cacheStat.mtimeMs > loaderStat!.mtimeMs) return outputPath;
-      const tempPath = join(this.sourceRoot, ".observablehq", "cache", `${this.targetPath}.${process.pid}`);
-      await prepareOutput(tempPath);
-      const tempFd = await open(tempPath, "w");
-      const tempFileStream = tempFd.createWriteStream({highWaterMark: 1024 * 1024});
-      const subprocess = spawn(this.command, this.args, {windowsHide: true, stdio: ["ignore", "pipe", "inherit"]});
-      subprocess.stdout.pipe(tempFileStream);
-      const code = await new Promise((resolve, reject) => {
-        subprocess.on("error", reject);
-        subprocess.on("close", resolve);
-      });
-      await tempFd.close();
-      console.info(
-        `${this.path} ${`${code === 0 ? success("success") : error("error")} ${outputBytes(
-          (await maybeStat(tempPath))?.size
-        )} in ${Math.floor(performance.now() - time)}ms`}`
+      const start = performance.now();
+      command.then(
+        (path) => {
+          console.info(
+            `${this.path} ${green("success")} ${formatSize(statSync(path).size)} in ${formatElapsed(start)}`
+          );
+        },
+        (error) => {
+          console.info(`${this.path} ${red("error")} after ${formatElapsed(start)}: ${error.message}`);
+        }
       );
-      if (code === 0) {
-        await mkdir(dirname(cachePath), {recursive: true});
-        await rename(tempPath, cachePath);
-      } else {
-        await unlink(tempPath);
-        throw new Error(`loader exited with code ${code}`);
-      }
-      return outputPath;
-    })();
-    command.finally(() => runningCommands.delete(this.path)).catch(() => {});
-    runningCommands.set(this.path, command);
+    }
     return command;
   }
 }
 
-const error = color(31);
-const success = color(32);
-const warning = color(33);
+const red = color(31);
+const green = color(32);
+const yellow = color(33);
 
 function color(code) {
   return process.stdout.isTTY ? (text) => `\x1b[${code}m${text}\x1b[0m` : String;
 }
 
-function outputBytes(size) {
-  if (!size) return warning("empty output");
+function formatSize(size) {
+  if (!size) return yellow("empty output");
   const e = Math.floor(Math.log(size) / Math.log(1024));
   return `output ${+(size / 1024 ** e).toFixed(2)} ${["bytes", "KiB", "MiB", "GiB", "TiB"][e]}`;
 }
+
+function formatElapsed(start) {
+  const elapsed = performance.now() - start;
+  return `${Math.floor(elapsed)}ms`;
+}

test/dataloaders-test.ts

@@ -5,17 +5,17 @@ import {Loader} from "../src/dataloader.js";
 describe("data loaders are called with the appropriate command", () => {
   it("a .js data loader is called with node", async () => {
     const loader = Loader.find("test", "dataloaders/data1.txt")!;
-    const out = await loader.load();
+    const out = await loader.load({verbose: false});
     assert.strictEqual(await readFile("test/" + out, "utf-8"), "node\n");
   });
   it("a .ts data loader is called with tsx", async () => {
-    const loader = Loader.find("test", "dataloaders/data2.txt");
-    const out = await loader!.load();
+    const loader = Loader.find("test", "dataloaders/data2.txt")!;
+    const out = await loader.load({verbose: false});
     assert.strictEqual(await readFile("test/" + out, "utf-8"), "tsx\n");
   });
   it("a .sh data loader is called as a shell script", async () => {
-    const loader = Loader.find("test", "dataloaders/data3.txt");
-    const out = await loader!.load();
+    const loader = Loader.find("test", "dataloaders/data3.txt")!;
+    const out = await loader.load({verbose: false});
     assert.strictEqual(await readFile("test/" + out, "utf-8"), "shell\n");
   });
 });