Split the prepare and build function

Split the logic in to to better define what is happening when.

Bug: none
Change-Id: Ibb5d7c7832b6cb1b38009a426bafb1be4a6b1ffa
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6439492
Reviewed-by: Benedikt Meurer <[email protected]>
Commit-Queue: Nikolay Vitkov <[email protected]>

Author: Lightning00Blade

scripts/devtools_build.mjs

@@ -5,10 +5,14 @@
 import childProcess from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import {performance} from 'node:perf_hooks';
+import { performance } from 'node:perf_hooks';
 import util from 'node:util';
 
-import {autoninjaExecutablePath, gnExecutablePath, rootPath} from './devtools_paths.js';
+import {
+  autoninjaExecutablePath,
+  gnExecutablePath,
+  rootPath,
+} from './devtools_paths.js';
 
 const execFile = util.promisify(childProcess.execFile);
 
@@ -74,7 +78,7 @@ export class FeatureSet {
    * Yields the command line parameters to pass to the invocation of
    * a Chrome binary for achieving the state of the feature set.
    */
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     const disabledFeatures = [...this.#disabled];
     if (disabledFeatures.length) {
       yield `--disable-features=${disabledFeatures.sort().join(',')}`;
@@ -104,15 +108,17 @@ export class FeatureSet {
       if (parts.length > 1) {
         const args = parts[1].split('/');
         if (args.length % 2 !== 0) {
-          throw new Error(`Invalid parameters '${parts[1]}' for feature ${feature}`);
+          throw new Error(
+            `Invalid parameters '${parts[1]}' for feature ${feature}`,
+          );
         }
         for (let i = 0; i < args.length; i += 2) {
           const key = args[i + 0];
           const value = args[i + 1];
           parameters[key] = value;
         }
       }
-      features.push({feature, parameters});
+      features.push({ feature, parameters });
     }
     return features;
   }
@@ -134,16 +140,16 @@ export class BuildError extends Error {
    * @param {string} options.target the target relative to `//out`.
    */
   constructor(step, options) {
-    const {cause, outDir, target} = options;
-    super(`Failed to build target ${target} in ${outDir}`, {cause});
+    const { cause, outDir, target } = options;
+    super(`Failed to build target ${target} in ${outDir}`, { cause });
     this.name = 'BuildError';
     this.step = step;
     this.target = target;
     this.outDir = outDir;
   }
 
   toString() {
-    const {stdout} = this.cause;
+    const { stdout } = this.cause;
     return stdout;
   }
 }
@@ -156,11 +162,9 @@ export class BuildError extends Error {
 
 /**
  * @param {string} target
- * @param {AbortSignal=} signal
- * @return {Promise<BuildResult>} a `BuildResult` with statistics for the build.
+ * @return {Promise<void>}
  */
-export async function build(target, signal) {
-  const startTime = performance.now();
+export async function prepareBuild(target) {
   const outDir = path.join(rootPath(), 'out', target);
 
   // Prepare the build directory first.
@@ -170,30 +174,37 @@ export async function build(target, signal) {
     try {
       const gnExe = gnExecutablePath();
       const gnArgs = ['-q', 'gen', outDir];
-      await execFile(gnExe, gnArgs, {signal});
+      await execFile(gnExe, gnArgs);
     } catch (cause) {
-      if (cause.name === 'AbortError') {
-        throw cause;
-      }
-      throw new BuildError(BuildStep.GN, {cause, outDir, target});
+      throw new BuildError(BuildStep.GN, { cause, outDir, target });
     }
   }
+}
+
+/**
+ * @param {string} target
+ * @param {AbortSignal=} signal
+ * @return {Promise<BuildResult>} a `BuildResult` with statistics for the build.
+ */
+export async function build(target, signal) {
+  const startTime = performance.now();
+  const outDir = path.join(rootPath(), 'out', target);
 
   // Build just the devtools-frontend resources in |outDir|. This is important
   // since we might be running in a full Chromium checkout and certainly don't
   // want to build all of Chromium first.
   try {
     const autoninjaExe = autoninjaExecutablePath();
     const autoninjaArgs = ['-C', outDir, '--quiet', 'devtools_all_files'];
-    await execFile(autoninjaExe, autoninjaArgs, {signal});
+    await execFile(autoninjaExe, autoninjaArgs, { signal });
   } catch (cause) {
     if (cause.name === 'AbortError') {
       throw cause;
     }
-    throw new BuildError(BuildStep.AUTONINJA, {cause, outDir, target});
+    throw new BuildError(BuildStep.AUTONINJA, { cause, outDir, target });
   }
 
   // Report the build result.
   const time = (performance.now() - startTime) / 1000;
-  return {time};
+  return { time };
 }

scripts/run_build.mjs

@@ -5,47 +5,55 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import yargs from 'yargs';
-import {hideBin} from 'yargs/helpers';
+import { hideBin } from 'yargs/helpers';
 
-import {build} from './devtools_build.mjs';
+import { build, prepareBuild } from './devtools_build.mjs';
 
 const argv = yargs(hideBin(process.argv))
-                 .option('target', {
-                   alias: 't',
-                   type: 'string',
-                   default: 'Default',
-                   description: 'Specify the target build subdirectory under //out',
-                 })
-                 .option('skip-initial-build', {
-                   type: 'boolean',
-                   default: false,
-                   description: 'Skip the initial build (use with --watch)',
-                   implies: 'watch',
-                 })
-                 .option('watch', {
-                   alias: 'w',
-                   type: 'boolean',
-                   default: false,
-                   description: 'Monitor for changes and automatically rebuild',
-                 })
-                 .usage('npm run build -- [options]')
-                 .help('help')
-                 .version(false)
-                 .parseSync();
+  .option('target', {
+    alias: 't',
+    type: 'string',
+    default: 'Default',
+    description: 'Specify the target build subdirectory under //out',
+  })
+  .option('skip-initial-build', {
+    type: 'boolean',
+    default: false,
+    description: 'Skip the initial build (use with --watch)',
+    implies: 'watch',
+  })
+  .option('watch', {
+    alias: 'w',
+    type: 'boolean',
+    default: false,
+    description: 'Monitor for changes and automatically rebuild',
+  })
+  .usage('npm run build -- [options]')
+  .help('help')
+  .version(false)
+  .parseSync();
 
-const {target, watch, skipInitialBuild} = argv;
+const { target, watch, skipInitialBuild } = argv;
 const timeFormatter = new Intl.NumberFormat('en-US', {
   style: 'unit',
   unit: 'second',
   unitDisplay: 'narrow',
   maximumFractionDigits: 2,
 });
 
+// Prepare the build target if not initialized.
+try {
+  await prepareBuild(target);
+} catch (error) {
+  console.log(error.toString());
+  process.exit(1);
+}
+
 // Perform an initial build (unless we should skip).
 if (!skipInitialBuild) {
   console.log('Building…');
   try {
-    const {time} = await build(target);
+    const { time } = await build(target);
     console.log(`Build ready (${timeFormatter.format(time)})`);
   } catch (error) {
     console.log(error.toString());
@@ -73,12 +81,12 @@ if (watch) {
     // Abort any currently running build.
     abortController.abort();
     abortController = new AbortController();
-    const {signal} = abortController;
+    const { signal } = abortController;
 
     buildPromise = buildPromise.then(async () => {
       try {
         console.log('Rebuilding...');
-        const {time} = await build(target, signal);
+        const { time } = await build(target, signal);
         console.log(`Rebuild successfully (${timeFormatter.format(time)})`);
       } catch (error) {
         if (error.name !== 'AbortError') {
@@ -90,10 +98,8 @@ if (watch) {
 
   const WATCHLIST = ['front_end', 'test'];
   for (const dirname of WATCHLIST) {
-    fs.watch(
-        dirname,
-        {recursive: true},
-        (eventType, filename) => watchCallback(eventType, path.join(dirname, filename)),
+    fs.watch(dirname, { recursive: true }, (eventType, filename) =>
+      watchCallback(eventType, path.join(dirname, filename)),
     );
   }
 }