Use execa for child_process calls

bin/lerna.js

@@ -6,23 +6,35 @@ const logger = require("../lib/logger");
 const yargs = require("yargs");
 const path = require("path");
 
+// the options grouped under "Global Options:" header
+const globalKeys = Object.keys(globalOptions).concat([
+  "loglevel",
+  "help",
+  "version",
+]);
+
+// workaround non-interactive yargs.terminalWidth() error
+// until https://github.com/yargs/yargs/pull/837 is released
+function terminalWidth() {
+  return typeof process.stdout.columns !== "undefined" ? process.stdout.columns : null;
+}
+
 logger.setLogLevel(yargs.argv.loglevel);
 
 yargs
   .epilogue("For more information, find our manual at https://github.com/lerna/lerna")
-  .usage("$ lerna [command] [flags]")
-  .wrap(yargs.terminalWidth())
+  .usage("Usage: $0 <command> [options]")
+  .wrap(terminalWidth())
   .option("loglevel", {
     default: "info",
     describe: "What level of logs to report. On failure, all logs are written to lerna-debug.log in the"
             + "current working directory.",
     type: "string",
     global: true
   })
-  .options(globalOptions).group(Object.keys(globalOptions), "Global Options:")
+  .options(globalOptions).group(globalKeys, "Global Options:")
   .commandDir(path.join(__dirname, "..", "lib", "commands"))
   .demandCommand()
-  .help()
+  .help("h").alias("h", "help")
+  .version().alias("v", "version")
   .argv;
-
-require("signal-exit").unload();

package.json

@@ -48,6 +48,7 @@
     "load-json-file": "^2.0.0",
     "lodash": "^4.17.4",
     "minimatch": "^3.0.0",
+    "p-finally": "^1.0.0",
     "path-exists": "^3.0.0",
     "progress": "^2.0.0",
     "read-cmd-shim": "^1.0.1",
@@ -56,6 +57,7 @@
     "safe-buffer": "^5.0.1",
     "semver": "^5.1.0",
     "signal-exit": "^3.0.2",
+    "strong-log-transformer": "^1.0.6",
     "temp-write": "^3.2.0",
     "write-json-file": "^2.0.0",
     "write-pkg": "^2.1.0",

src/ChildProcessUtilities.js

@@ -1,113 +1,46 @@
-import child from "child_process";
-import spawn from "cross-spawn";
 import { EventEmitter } from "events";
+import execa from "execa";
+import pFinally from "p-finally";
+import logTransformer from "strong-log-transformer";
 
 // Keep track of how many live children we have.
 let children = 0;
 
-// maxBuffer value for running exec
-const MAX_BUFFER = 500 * 1024;
-
 // This is used to alert listeners when all children have exited.
-const emitter = new EventEmitter;
+const emitter = new EventEmitter();
 
 export default class ChildProcessUtilities {
-  static exec(command, opts, callback) {
-    const mergedOpts = Object.assign({
-      maxBuffer: MAX_BUFFER
-    }, opts);
-    return ChildProcessUtilities.registerChild(
-      child.exec(command, mergedOpts, (err, stdout, stderr) => {
-        if (err != null) {
-
-          // If the error from `child.exec` is just that the child process
-          // emitted too much on stderr, then that stderr output is likely to
-          // be useful.
-          if (/^stderr maxBuffer exceeded/.test(err.message)) {
-            err = `Error: ${err.message}.  Partial output follows:\n\n${stderr}`;
-          }
-
-          callback(err || stderr, stdout);
-        } else {
-          callback(null, stdout);
-        }
-      })
-    );
-  }
+  static exec(command, args, opts, callback) {
+    const options = Object.assign({}, opts);
+    options.stdio = "pipe"; // node default
 
-  static execSync(command, opts) {
-    const mergedOpts = Object.assign({
-      encoding: "utf8",
-      maxBuffer: MAX_BUFFER
-    }, opts);
-
-    let stdout = child.execSync(command, mergedOpts);
-    if (stdout) {
-      // stdout is undefined when stdio[1] is anything other than "pipe"
-      // and there's no point trimming an empty string (no piped stdout)
-      stdout = stdout.trim();
-    }
+    return _spawn(command, args, options, callback);
+  }
 
-    return stdout;
+  static execSync(command, args, opts) {
+    return execa.sync(command, args, opts).stdout;
   }
 
   static spawn(command, args, opts, callback) {
-    let output = "";
-
-    const childProcess = _spawn(command, args, opts, (err) => callback(err, output));
+    const options = Object.assign({}, opts);
+    options.stdio = "inherit";
 
-    // By default stderr, stdout are inherited from us (just sent to _our_ output).
-    // If the caller overrode that to "pipe", then we'll gather that up and
-    // call back with it in case of failure.
-    if (childProcess.stderr) {
-      childProcess.stderr.setEncoding("utf8");
-      childProcess.stderr.on("data", (chunk) => output += chunk);
-    }
-
-    if (childProcess.stdout) {
-      childProcess.stdout.setEncoding("utf8");
-      childProcess.stdout.on("data", (chunk) => output += chunk);
-    }
+    return _spawn(command, args, options, callback);
   }
 
   static spawnStreaming(command, args, opts, prefix, callback) {
-    opts = Object.assign({}, opts, {
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    const childProcess = _spawn(command, args, opts, callback);
-
-    ["stdout", "stderr"].forEach((stream) => {
-      let partialLine = "";
-      childProcess[stream].setEncoding("utf8")
-        .on("data", (chunk) => {
-          const lines = chunk.split("\n");
-          lines[0] = partialLine + lines[0];
-          partialLine = lines.pop();
-          lines.forEach((line) => process[stream].write(prefix + line + "\n"));
-        })
-        .on("end", () => {
-          if (partialLine) {
-
-            // If the child process ended its output with no final newline we
-            // need to flush that out.  We'll add a newline ourselves so we
-            // don't end up with output from multiple children on the same
-            // line.
-            process[stream].write(prefix + partialLine + "\n");
-          }
-        });
-    });
-  }
+    const options = Object.assign({}, opts);
+    options.stdio = ["ignore", "pipe", "pipe"];
+
+    const spawned = _spawn(command, args, options, callback);
+
+    const prefixedStdout = logTransformer({ tag: `${prefix}:` });
+    const prefixedStderr = logTransformer({ tag: `${prefix} ERROR`, mergeMultiline: true });
 
-  static registerChild(child) {
-    children++;
-    child.on("exit", () => {
-      children--;
-      if (children === 0) {
-        emitter.emit("empty");
-      }
-    });
-    return child;
+    spawned.stdout.pipe(prefixedStdout).pipe(process.stdout);
+    spawned.stderr.pipe(prefixedStderr).pipe(process.stderr);
+
+    return spawned;
   }
 
   static getChildProcessCount() {
@@ -119,18 +52,29 @@ export default class ChildProcessUtilities {
   }
 }
 
+function registerChild(child) {
+  children++;
+
+  pFinally(child, () => {
+    children--;
+
+    if (children === 0) {
+      emitter.emit("empty");
+    }
+  });
+}
+
 function _spawn(command, args, opts, callback) {
-  return ChildProcessUtilities.registerChild(
-    spawn(command, args, Object.assign({
-      stdio: "inherit"
-    }, opts))
-      .on("error", () => {})
-      .on("close", (code) => {
-        if (code) {
-          callback(`Command exited with status ${code}: ${command} ${args.join(" ")}`);
-        } else {
-          callback(null);
-        }
-      })
-  );
+  const child = execa(command, args, opts);
+
+  registerChild(child);
+
+  if (callback) {
+    child.then(
+      (result) => callback(null, result.stdout),
+      (err) => callback(err)
+    );
+  }
+
+  return child;
 }

src/Command.js

@@ -15,7 +15,6 @@ export const builder = {
     type: "number",
     requiresArg: true,
     default: DEFAULT_CONCURRENCY,
-    coerce: (val) => Math.max(1, val)
   },
   "ignore": {
     describe: "Ignores packages with names matching the given glob (Works only in combination with the "
@@ -41,6 +40,7 @@ export const builder = {
   },
   "sort": {
     describe: "Sort packages topologically",
+    type: "boolean",
     default: true
   }
 };

src/ConventionalCommitUtilities.js

@@ -11,29 +11,21 @@ const CHANGELOG_HEADER = dedent(`# Change Log
   All notable changes to this project will be documented in this file.
   See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.`);
 
-const RECOMMEND_CLI = require.resolve("conventional-recommended-bump/cli.js");
-const CHANGELOG_CLI = require.resolve("conventional-changelog-cli/cli.js");
-
 export default class ConventionalCommitUtilities {
   @logger.logifySync()
   static recommendVersion(pkg, opts) {
-    const name = pkg.name;
-    const version = pkg.version;
-    const pkgLocation = pkg.location;
-
     const recommendedBump = ChildProcessUtilities.execSync(
-      `${RECOMMEND_CLI} -l ${name} --commit-path=${pkgLocation} -p angular`,
+      "conventional-recommended-bump",
+      ["-l", pkg.name, "--commit-path", pkg.location, "-p", "angular"],
       opts
     );
 
-    return semver.inc(version, recommendedBump);
+    return semver.inc(pkg.version, recommendedBump);
   }
 
   @logger.logifySync()
   static updateChangelog(pkg, opts) {
-    const name = pkg.name;
-    const pkgLocation = pkg.location;
-    const pkgJsonLocation = path.join(pkgLocation, "package.json");
+    const pkgJsonLocation = path.join(pkg.location, "package.json");
     const changelogLocation = ConventionalCommitUtilities.changelogLocation(pkg);
 
     let changelogContents = "";
@@ -44,7 +36,8 @@ export default class ConventionalCommitUtilities {
     // run conventional-changelog-cli to generate the markdown
     // for the upcoming release.
     const newEntry = ChildProcessUtilities.execSync(
-      `${CHANGELOG_CLI} -l ${name} --commit-path=${pkgLocation} --pkg=${pkgJsonLocation} -p angular`,
+      "conventional-changelog",
+      ["-l", pkg.name, "--commit-path", pkg.location, "--pkg", pkgJsonLocation, "-p", "angular"],
       opts
     );
 

src/FileSystemUtilities.js

@@ -12,6 +12,11 @@ function ensureEndsWithNewLine(string) {
   return ENDS_WITH_NEW_LINE.test(string) ? string : string + "\n";
 }
 
+// globs only return directories with a trailing slash
+function trailingSlash(filePath) {
+  return path.normalize(`${filePath}/`);
+}
+
 export default class FileSystemUtilities {
   @logger.logifyAsync()
   static mkdirp(filePath, callback) {
@@ -59,16 +64,14 @@ export default class FileSystemUtilities {
   }
 
   @logger.logifyAsync()
-  static rimraf(filePath, callback) {
-
+  static rimraf(dirPath, callback) {
     // Shelling out to a child process for a noop is expensive.
-    // Checking if `filePath` exists to be removed is cheap.
+    // Checking if `dirPath` exists to be removed is cheap.
     // This lets us short-circuit if we don't have anything to do.
-    pathExists(filePath).then((exists) => {
+    pathExists(dirPath).then((exists) => {
       if (!exists) return callback();
 
-      // Note: if rimraf moves the location of its executable, this will need to be updated
-      ChildProcessUtilities.spawn(require.resolve("rimraf/bin"), [filePath], {}, callback);
+      ChildProcessUtilities.spawn("rimraf", ["--no-glob", trailingSlash(dirPath)], {}, callback);
     });
   }