Update: --continue-on-error option (fixes #34)

Author: mysticatea

README.md

@@ -33,17 +33,30 @@ npm install npm-run-all
 ## Usage
 
 ```
-Usage: npm-run-all [OPTIONS] [...tasks]
+Usage: npm-run-all [...tasks] [OPTIONS]
 
   Run specified tasks.
 
   Options:
     -h, --help                  Print this text.
-    -p, --parallel [...tasks]   Run a group of tasks in parallel.
-    -s, --sequential [...tasks] Run a group of tasks in sequencial.
-        --serial [...tasks]     '--serial' is a synonym of '--sequential'.
     -v, --version               Print version number.
+
+    -c, --continue-on-error     Set the flag to ignore errors to the current
+                                group of tasks.
     --silent                    Set "silent" to the log level of npm.
+
+    -p, --parallel [...tasks]   Run a group of tasks in parallel.
+                                e.g. 'npm-run-all -p foo bar' is similar to
+                                     'npm run foo & npm run bar'.
+    -P [...tasks]               Run a group of tasks in parallel as ignoring
+                                errors. This is shorthand of '-p -c [...tasks]'.
+
+    -s, --sequential [...tasks] Run a group of tasks in sequential.
+        --serial [...tasks]     '--serial' is a synonym of '--sequential'.
+                                e.g. 'npm-run-all -s foo bar' is similar to
+                                     'npm run foo && npm run bar'.
+    -S [...tasks]               Run a group of tasks in sequential as ignoring
+                                errors. This is shorthand of '-s -c [...tasks]'.
 ```
 
 ### Run tasks sequentially / serially
@@ -123,6 +136,25 @@ If we use a globstar `**`, runs both sub tasks and sub-sub tasks.
 This matching rule is similar to [glob](https://www.npmjs.com/package/glob#glob-primer).
 The Difference is one -- the separator is `:`, instead of `/`.
 
+### Continue on error
+
+We can use `--continue-on-error` option to ignore errors.
+
+```
+npm-run-all --sequential --continue-on-error foo bar
+npm-run-all --parallel --continue-on-error foo bar
+```
+
+`npm-run-all` stops subsequence when a task exited with non-zero code by default.
+But when `--continue-on-error` was specified, `npm-run-all` continues subsequence on error.
+
+There are shorthands.
+
+```
+npm-run-all -S foo bar
+npm-run-all -P foo bar
+```
+
 ## Node API
 
 ```
@@ -142,6 +174,9 @@ Run npm-scripts.
   - **options.parallel** `boolean` --
     A flag to run tasks in parallel.
     Default is `false`.
+  - **options.continueOnError** `boolean` --
+    A flag to ignore errors.
+    Default is `false`.
   - **options.stdin** `stream.Readable|null` --
     A readable stream to send to the stdin of npm-scripts.
     Default is nothing.

src/bin/help.js

@@ -13,18 +13,31 @@
  */
 export default function printHelp(output) {
     output.write(`
-Usage: npm-run-all [OPTIONS] [...tasks]
+Usage: npm-run-all [...tasks] [OPTIONS]
 
   Run specified tasks.
 
   Options:
     -h, --help                  Print this text.
-    -p, --parallel [...tasks]   Run a group of tasks in parallel.
-    -s, --sequential [...tasks] Run a group of tasks in sequencial.
-        --serial [...tasks]     '--serial' is a synonym of '--sequential'.
     -v, --version               Print version number.
+
+    -c, --continue-on-error     Set the flag to ignore errors to the current
+                                group of tasks.
     --silent                    Set "silent" to the log level of npm.
 
+    -p, --parallel [...tasks]   Run a group of tasks in parallel.
+                                e.g. 'npm-run-all -p foo bar' is similar to
+                                     'npm run foo & npm run bar'.
+    -P [...tasks]               Run a group of tasks in parallel as ignoring
+                                errors. This is shorthand of '-p -c [...tasks]'.
+
+    -s, --sequential [...tasks] Run a group of tasks in sequential.
+        --serial [...tasks]     '--serial' is a synonym of '--sequential'.
+                                e.g. 'npm-run-all -s foo bar' is similar to
+                                     'npm run foo && npm run bar'.
+    -S [...tasks]               Run a group of tasks in sequential as ignoring
+                                errors. This is shorthand of '-s -c [...tasks]'.
+
   See Also:
     https://github.com/mysticatea/npm-run-all#readme
 `);

src/bin/main.js

@@ -51,27 +51,51 @@ function createPackageConfig() {
  * Parses arguments.
  *
  * @param {string[]} args - Arguments to parse.
- * @returns {{parallel: boolean, patterns: string[], packageConfig: object}[]} A running plan.
+ * @returns {{
+ *      groups: {
+ *          parallel: boolean,
+ *          continueOnError: boolean,
+ *          patterns: string[]
+ *      }[],
+ *      packageConfig: object
+ * }} A running plan.
  */
 function parse(args) {
     const packageConfig = createPackageConfig();
-    const queue = [{parallel: false, patterns: [], packageConfig}];
+    const groups = [{
+        parallel: false,
+        continueOnError: false,
+        patterns: []
+    }];
 
     for (let i = 0; i < args.length; ++i) {
         const arg = args[i];
 
         switch (arg) {
+            case "-S":
             case "-s":
             case "--sequential":
             case "--serial":
-                if (queue[queue.length - 1].parallel) {
-                    queue.push({parallel: false, patterns: [], packageConfig});
-                }
+                groups.push({
+                    parallel: false,
+                    continueOnError: arg === "-S",
+                    patterns: []
+                });
                 break;
 
+            case "-P":
             case "-p":
             case "--parallel":
-                queue.push({parallel: true, patterns: [], packageConfig});
+                groups.push({
+                    parallel: true,
+                    continueOnError: arg === "-P",
+                    patterns: []
+                });
+                break;
+
+            case "-c":
+            case "--continue-on-error":
+                groups[groups.length - 1].continueOnError = true;
                 break;
 
             case "--silent":
@@ -92,14 +116,14 @@ function parse(args) {
                     throw new Error(`Invalid Option: ${arg}`);
                 }
                 else {
-                    queue[queue.length - 1].patterns.push(arg);
+                    groups[groups.length - 1].patterns.push(arg);
                 }
                 break;
             }
         }
     }
 
-    return queue;
+    return {groups, packageConfig};
 }
 
 /**
@@ -118,9 +142,10 @@ export default function npmRunAll(args, stdout, stderr) {
             args.indexOf("--silent") !== -1 ||
             process.env.npm_config_loglevel === "silent"
         );
+        const {groups, packageConfig} = parse(args);
 
-        return parse(args).reduce(
-            (prev, {patterns, parallel, packageConfig}) => {
+        return groups.reduce(
+            (prev, {patterns, parallel, continueOnError}) => {
                 if (patterns.length === 0) {
                     return prev;
                 }
@@ -131,6 +156,7 @@ export default function npmRunAll(args, stdout, stderr) {
                         stderr,
                         stdin,
                         parallel,
+                        continueOnError,
                         packageConfig,
                         silent
                     }

src/lib/npm-run-all.js

@@ -87,6 +87,9 @@ function toOverwriteOptions(config) {
  * @param {boolean} options.silent -
  *   The flag to set `silent` to the log level of npm.
  *   Default is `false`.
+ * @param {boolean} options.continueOnError -
+ *   The flag to ignore errors.
+ *   Default is `false`.
  * @returns {Promise}
  *   A promise object which becomes fullfilled when all npm-scripts are completed.
  */
@@ -99,7 +102,8 @@ export default function npmRunAll(
         stderr = null,
         taskList = null,
         packageConfig = null,
-        silent = false
+        silent = false,
+        continueOnError = false
     } = {}
 ) {
     try {
@@ -121,7 +125,7 @@ export default function npmRunAll(
 
         const tasks = matchTasks(taskList || readTasks(), patterns);
         const runTasks = parallel ? runTasksInParallel : runTasksInSequencial;
-        return runTasks(tasks, stdin, stdout, stderr, prefixOptions);
+        return runTasks(tasks, stdin, stdout, stderr, prefixOptions, continueOnError);
     }
     catch (err) {
         return Promise.reject(new Error(err.message));

src/lib/run-tasks-in-parallel.js

@@ -28,15 +28,20 @@ import runTask from "./run-task";
  *   Otherwise, makes a pipe.
  * @param {string[]} prefixOptions -
  *   An array of options which are inserted before the task name.
+ * @param {boolean} continueOnError -
+ *   The flag to ignore errors.
  * @returns {Promise}
  *   A promise object which becomes fullfilled when all npm-scripts are completed.
  * @private
  */
-export default function runTasksInParallel(tasks, stdin, stdout, stderr, prefixOptions) {
+export default function runTasksInParallel(tasks, stdin, stdout, stderr, prefixOptions, continueOnError) {
     // When one of tasks exited with non-zero, abort all tasks.
     // And wait for all tasks exit.
     let nonZeroExited = null;
     const taskPromises = tasks.map(task => runTask(task, stdin, stdout, stderr, prefixOptions));
+    if (continueOnError) {
+        return Promise.all(taskPromises);
+    }
     const parallelPromise = Promise.all(taskPromises.map(p =>
         p.then(item => {
             if (nonZeroExited == null && item.code) {

src/lib/run-tasks-in-sequencial.js

@@ -42,11 +42,19 @@ function rejectIfNonZeroExit(result) {
  *   Otherwise, makes a pipe.
  * @param {string[]} prefixOptions -
  *   An array of options which are inserted before the task name.
+ * @param {boolean} continueOnError -
+ *   The flag to ignore errors.
  * @returns {Promise}
  *   A promise object which becomes fullfilled when all npm-scripts are completed.
  * @private
  */
-export default function runTasksInSequencial(tasks, stdin, stdout, stderr, prefixOptions) {
+export default function runTasksInSequencial(tasks, stdin, stdout, stderr, prefixOptions, continueOnError) {
+    if (continueOnError) {
+        return tasks.reduce(
+            (prev, task) => prev.then(() => runTask(task, stdin, stdout, stderr, prefixOptions)),
+            START_PROMISE
+        );
+    }
     return tasks.reduce(
         (prev, task) => prev.then(result => {
             rejectIfNonZeroExit(result);

test/parallel.js

@@ -102,4 +102,39 @@ describe("[parallel] npm-run-all", () => {
             assert(result() == null || result() === "a");
         })
     );
+
+    describe("should continue on error when --continue-on-error option was specified:", () => {
+        it("lib version", () =>
+            runAll(["test-task:append a", "test-task:error", "test-task:append b"], {parallel: true, continueOnError: true})
+                .then(() => {
+                    assert(
+                        result() === "abab" ||
+                        result() === "baba" ||
+                        result() === "abba" ||
+                        result() === "baab");
+                })
+        );
+
+        it("command version", () =>
+            command(["--parallel", "test-task:append a", "test-task:error", "test-task:append b", "--continue-on-error"])
+                .then(() => {
+                    assert(
+                        result() === "abab" ||
+                        result() === "baba" ||
+                        result() === "abba" ||
+                        result() === "baab");
+                })
+        );
+
+        it("command version (-P shorthand)", () =>
+            command(["-P", "test-task:append a", "test-task:error", "test-task:append b"])
+                .then(() => {
+                    assert(
+                        result() === "abab" ||
+                        result() === "baba" ||
+                        result() === "abba" ||
+                        result() === "baab");
+                })
+        );
+    });
 });

test/sequential.js

@@ -69,4 +69,27 @@ describe("[sequencial] npm-run-all", () => {
             assert(result() == null || result() === "a");
         })
     );
+
+    describe("should continue on error when --continue-on-error option was specified:", () => {
+        it("lib version", () =>
+            runAll(["test-task:append a", "test-task:error", "test-task:append b"], {continueOnError: true})
+                .then(() => {
+                    assert(result() === "aabb");
+                })
+        );
+
+        it("command version", () =>
+            command(["test-task:append a", "test-task:error", "test-task:append b", "--continue-on-error"])
+                .then(() => {
+                    assert(result() === "aabb");
+                })
+        );
+
+        it("command version (-S shorthand)", () =>
+            command(["-S", "test-task:append a", "test-task:error", "test-task:append b"])
+                .then(() => {
+                    assert(result() === "aabb");
+                })
+        );
+    });
 });