concurrently 6.0.0 → 6.2.0

package/README.md

@@ -147,7 +147,7 @@ Prefix styling
                           - Available background colors: bgBlack, bgRed,
                           bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite
                           See https://www.npmjs.com/package/chalk for more
-                          information.            [string] [default: "gray.dim"]
+                          information.            [string] [default: "reset"]
   -l, --prefix-length     Limit how many characters of the command is displayed
                           in prefix. The option can be used to shorten the
                           prefix when it is set to "command"
@@ -169,9 +169,10 @@ Killing other processes
                          code                                          [boolean]
 
 Restarting
-  --restart-tries  How many times a process that died should restart.
+      --restart-tries  How many times a process that died should restart.
+                       Negative numbers will make the process restart forever.
                                                            [number] [default: 0]
-  --restart-after  Delay time to respawn the process, in milliseconds.
+      --restart-after  Delay time to respawn the process, in milliseconds.
                                                            [number] [default: 0]
 
 Options:
@@ -257,9 +258,9 @@ concurrently can be used programmatically by using the API documented below:
 
 > Returns: a `Promise` that resolves if the run was successful (according to `successCondition` option),
 > or rejects, containing an array of objects with information for each command that has been run, in the order
-> that the commands terminated. The objects have the shape `{ command, index, exitCode }`, where `command` is the object
-> passed in the `commands` array and `index` its index there. Default values (empty strings or objects) are returned for
-> the fields that were not specified.
+> that the commands terminated. The objects have the shape `{ command, index, exitCode, killed }`, where `command` is the object
+> passed in the `commands` array, `index` its index there and `killed` indicates if the process was killed as a result of 
+> `killOthers`. Default values (empty strings or objects) are returned for the fields that were not specified.
 
 Example:
 

package/bin/concurrently.js

@@ -107,7 +107,9 @@ const args = yargs
 
         // Restarting
         'restart-tries': {
-            describe: 'How many times a process that died should restart.',
+            describe:
+                'How many times a process that died should restart.\n' +
+                'Negative numbers will make the process restart forever.',
             default: defaults.restartTries,
             type: 'number'
         },

package/bin/concurrently.spec.js

@@ -0,0 +1,365 @@
+const readline = require('readline');
+const _ = require('lodash');
+const Rx = require('rxjs');
+const { buffer, map } = require('rxjs/operators');
+const spawn = require('spawn-command');
+
+const isWindows = process.platform === 'win32';
+const createKillMessage = prefix => new RegExp(
+    _.escapeRegExp(prefix) +
+    ' exited with code ' +
+    (isWindows ? 1 : '(SIGTERM|143)')
+);
+
+const run = args => {
+    const child = spawn('node ./concurrently.js ' + args, {
+        cwd: __dirname,
+        env: Object.assign({}, process.env, {
+            // When upgrading from jest 23 -> 24, colors started printing in the test output.
+            // They are forcibly disabled here
+            FORCE_COLOR: 0
+        }),
+    });
+
+    const stdout = readline.createInterface({
+        input: child.stdout,
+        output: null
+    });
+
+    const stderr = readline.createInterface({
+        input: child.stderr,
+        output: null
+    });
+
+    const close = Rx.fromEvent(child, 'close');
+    const log = Rx.merge(
+        Rx.fromEvent(stdout, 'line'),
+        Rx.fromEvent(stderr, 'line')
+    ).pipe(map(data => data.toString()));
+
+    return {
+        close,
+        log,
+        stdin: child.stdin,
+        pid: child.pid
+    };
+};
+
+it('has help command', done => {
+    run('--help').close.subscribe(event => {
+        expect(event[0]).toBe(0);
+        done();
+    }, done);
+});
+
+it('has version command', done => {
+    Rx.combineLatest(
+        run('--version').close,
+        run('-V').close,
+        run('-v').close
+    ).subscribe(events => {
+        expect(events[0][0]).toBe(0);
+        expect(events[1][0]).toBe(0);
+        expect(events[2][0]).toBe(0);
+        done();
+    }, done);
+});
+
+describe('exiting conditions', () => {
+    it('is of success by default when running successful commands', done => {
+        run('"echo foo" "echo bar"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBe(0);
+                done();
+            }, done);
+    });
+
+    it('is of failure by default when one of the command fails', done => {
+        run('"echo foo" "exit 1"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBeGreaterThan(0);
+                done();
+            }, done);
+    });
+
+    it('is of success when --success=first and first command to exit succeeds', done => {
+        run('--success=first "echo foo" "sleep 0.5 && exit 1"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBe(0);
+                done();
+            }, done);
+    });
+
+    it('is of failure when --success=first and first command to exit fails', done => {
+        run('--success=first "exit 1" "sleep 0.5 && echo foo"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBeGreaterThan(0);
+                done();
+            }, done);
+    });
+
+    it('is of success when --success=last and last command to exit succeeds', done => {
+        run('--success=last "exit 1" "sleep 0.5 && echo foo"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBe(0);
+                done();
+            }, done);
+    });
+
+    it('is of failure when --success=last and last command to exit fails', done => {
+        run('--success=last "echo foo" "sleep 0.5 && exit 1"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBeGreaterThan(0);
+                done();
+            }, done);
+    });
+
+    it.skip('is of success when a SIGINT is sent', done => {
+        const child = run('"node fixtures/read-echo.js"');
+        child.close.subscribe(exit => {
+            // TODO This is null within Node, but should be 0 outside (eg from real terminal)
+            expect(exit[0]).toBe(0);
+            done();
+        }, done);
+
+        process.kill(child.pid, 'SIGINT');
+    });
+
+    it('is aliased to -s', done => {
+        run('-s last "exit 1" "sleep 0.5 && echo foo"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBe(0);
+                done();
+            }, done);
+    });
+});
+
+describe('--raw', () => {
+    it('is aliased to -r', done => {
+        const child = run('-r "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toHaveLength(2);
+            expect(lines).toContainEqual(expect.stringContaining('foo'));
+            expect(lines).toContainEqual(expect.stringContaining('bar'));
+            done();
+        }, done);
+    });
+
+    it('does not log any extra output', done => {
+        const child = run('--raw "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toHaveLength(2);
+            expect(lines).toContainEqual(expect.stringContaining('foo'));
+            expect(lines).toContainEqual(expect.stringContaining('bar'));
+            done();
+        }, done);
+    });
+});
+
+describe('--names', () => {
+    it('is aliased to -n', done => {
+        const child = run('-n foo,bar "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[bar] bar'));
+            done();
+        }, done);
+    });
+
+    it('prefixes with names', done => {
+        const child = run('--names foo,bar "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[bar] bar'));
+            done();
+        }, done);
+    });
+
+    it('is split using --name-separator arg', done => {
+        const child = run('--names "foo|bar" --name-separator "|" "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[bar] bar'));
+            done();
+        }, done);
+    });
+});
+
+describe('--prefix', () => {
+    it('is alised to -p', done => {
+        const child = run('-p command "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[echo foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[echo bar] bar'));
+            done();
+        }, done);
+    });
+
+    it('specifies custom prefix', done => {
+        const child = run('--prefix command "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[echo foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[echo bar] bar'));
+            done();
+        }, done);
+    });
+});
+
+describe('--prefix-length', () => {
+    it('is alised to -l', done => {
+        const child = run('-p command -l 5 "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[ec..o] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[ec..r] bar'));
+            done();
+        }, done);
+    });
+
+    it('specifies custom prefix length', done => {
+        const child = run('--prefix command --prefix-length 5 "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[ec..o] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[ec..r] bar'));
+            done();
+        }, done);
+    });
+});
+
+describe('--restart-tries', () => {
+    it('changes how many times a command will restart', done => {
+        const child = run('--restart-tries 1 "exit 1"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toEqual([
+                expect.stringContaining('[0] exit 1 exited with code 1'),
+                expect.stringContaining('[0] exit 1 restarted'),
+                expect.stringContaining('[0] exit 1 exited with code 1'),
+            ]);
+            done();
+        }, done);
+    });
+});
+
+describe('--kill-others', () => {
+    it('is alised to -k', done => {
+        const child = run('-k "sleep 10" "exit 0"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 0 exited with code 0'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] sleep 10')));
+            done();
+        }, done);
+    });
+
+    it('kills on success', done => {
+        const child = run('--kill-others "sleep 10" "exit 0"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 0 exited with code 0'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] sleep 10')));
+            done();
+        }, done);
+    });
+
+    it('kills on failure', done => {
+        const child = run('--kill-others "sleep 10" "exit 1"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 1 exited with code 1'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] sleep 10')));
+            done();
+        }, done);
+    });
+});
+
+describe('--kill-others-on-fail', () => {
+    it('does not kill on success', done => {
+        const child = run('--kill-others-on-fail "sleep 0.5" "exit 0"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 0 exited with code 0'));
+            expect(lines).toContainEqual(expect.stringContaining('[0] sleep 0.5 exited with code 0'));
+            done();
+        }, done);
+    });
+
+    it('kills on failure', done => {
+        const child = run('--kill-others-on-fail "sleep 10" "exit 1"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 1 exited with code 1'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] sleep 10')));
+            done();
+        }, done);
+    });
+});
+
+describe('--handle-input', () => {
+    it('is aliased to -i', done => {
+        const child = run('-i "node fixtures/read-echo.js"');
+        child.log.subscribe(line => {
+            if (/READING/.test(line)) {
+                child.stdin.write('stop\n');
+            }
+
+            if (/\[0\] stop/.test(line)) {
+                done();
+            }
+        }, done);
+    });
+
+    it('forwards input to first process by default', done => {
+        const child = run('--handle-input "node fixtures/read-echo.js"');
+        child.log.subscribe(line => {
+            if (/READING/.test(line)) {
+                child.stdin.write('stop\n');
+            }
+
+            if (/\[0\] stop/.test(line)) {
+                done();
+            }
+        }, done);
+    });
+
+
+    it('forwards input to process --default-input-target', done => {
+        const lines = [];
+        const child = run('-ki --default-input-target 1 "node fixtures/read-echo.js" "node fixtures/read-echo.js"');
+        child.log.subscribe(line => {
+            lines.push(line);
+            if (/\[1\] READING/.test(line)) {
+                child.stdin.write('stop\n');
+            }
+        }, done);
+
+        child.close.subscribe(exit => {
+            expect(exit[0]).toBeGreaterThan(0);
+            expect(lines).toContainEqual(expect.stringContaining('[1] stop'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node fixtures/read-echo.js')));
+            done();
+        }, done);
+    });
+
+    it('forwards input to specified process', done => {
+        const lines = [];
+        const child = run('-ki "node fixtures/read-echo.js" "node fixtures/read-echo.js"');
+        child.log.subscribe(line => {
+            lines.push(line);
+            if (/\[1\] READING/.test(line)) {
+                child.stdin.write('1:stop\n');
+            }
+        }, done);
+
+        child.close.subscribe(exit => {
+            expect(exit[0]).toBeGreaterThan(0);
+            expect(lines).toContainEqual(expect.stringContaining('[1] stop'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node fixtures/read-echo.js')));
+            done();
+        }, done);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "concurrently",
-  "version": "6.0.0",
+  "version": "6.2.0",
   "description": "Run commands concurrently",
   "main": "index.js",
   "bin": {
@@ -31,7 +31,7 @@
   "dependencies": {
     "chalk": "^4.1.0",
     "date-fns": "^2.16.1",
-    "lodash": "^4.17.20",
+    "lodash": "^4.17.21",
     "read-pkg": "^5.2.0",
     "rxjs": "^6.6.3",
     "spawn-command": "^0.0.2-1",

package/src/command-parser/expand-npm-shortcut.spec.js

@@ -0,0 +1,36 @@
+const ExpandNpmShortcut = require('./expand-npm-shortcut');
+const parser = new ExpandNpmShortcut();
+
+it('returns same command if no npm: prefix is present', () => {
+    const commandInfo = {
+        name: 'echo',
+        command: 'echo foo'
+    };
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+for (const npmCmd of ['npm', 'yarn', 'pnpm']) {
+    describe(`with ${npmCmd}: prefix`, () => {
+        it(`expands to "${npmCmd} run <script> <args>"`, () => {
+            const commandInfo = {
+                name: 'echo',
+                command: `${npmCmd}:foo -- bar`
+            };
+            expect(parser.parse(commandInfo)).toEqual({
+                name: 'echo',
+                command: `${npmCmd} run foo -- bar`
+            });
+        });
+
+        it('sets name to script name if none', () => {
+            const commandInfo = {
+                command: `${npmCmd}:foo -- bar`
+            };
+            expect(parser.parse(commandInfo)).toEqual({
+                name: 'foo',
+                command: `${npmCmd} run foo -- bar`
+            });
+        });
+    });
+
+}

package/src/command-parser/expand-npm-wildcard.spec.js

@@ -0,0 +1,58 @@
+const ExpandNpmWildcard = require('./expand-npm-wildcard');
+
+let parser, readPkg;
+
+beforeEach(() => {
+    readPkg = jest.fn();
+    parser = new ExpandNpmWildcard(readPkg);
+});
+
+it('returns same command if not an npm run command', () => {
+    const commandInfo = {
+        command: 'npm test'
+    };
+
+    expect(readPkg).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+it('returns same command if no wildcard present', () => {
+    const commandInfo = {
+        command: 'npm run foo bar'
+    };
+
+    expect(readPkg).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+it('expands to nothing if no scripts exist in package.json', () => {
+    readPkg.mockReturnValue({});
+
+    expect(parser.parse({ command: 'npm run foo-*-baz qux' })).toEqual([]);
+});
+
+for (const npmCmd of ['npm', 'yarn', 'pnpm']) {
+    describe(`with an ${npmCmd}: prefix`, () => {
+        it('expands to all scripts matching pattern', () => {
+            readPkg.mockReturnValue({
+                scripts: {
+                    'foo-bar-baz': '',
+                    'foo--baz': '',
+                }
+            });
+
+            expect(parser.parse({ command: `${npmCmd} run foo-*-baz qux` })).toEqual([
+                { name: 'foo-bar-baz', command: `${npmCmd} run foo-bar-baz qux` },
+                { name: 'foo--baz', command: `${npmCmd} run foo--baz qux` },
+            ]);
+        });
+
+        it('caches scripts upon calls', () => {
+            readPkg.mockReturnValue({});
+            parser.parse({ command: `${npmCmd} run foo-*-baz qux` });
+            parser.parse({ command: `${npmCmd} run foo-*-baz qux` });
+
+            expect(readPkg).toHaveBeenCalledTimes(1);
+        });
+    });
+}

package/src/command-parser/strip-quotes.spec.js

@@ -0,0 +1,20 @@
+const StripQuotes = require('./strip-quotes');
+const parser = new StripQuotes();
+
+it('returns command as is if no single/double quote at the beginning', () => {
+    expect(parser.parse({ command: 'echo foo' })).toEqual({ command: 'echo foo' });
+});
+
+it('strips single quotes', () => {
+    expect(parser.parse({ command: '\'echo foo\'' })).toEqual({ command: 'echo foo' });
+});
+
+it('strips double quotes', () => {
+    expect(parser.parse({ command: '"echo foo"' })).toEqual({ command: 'echo foo' });
+});
+
+it('does not remove quotes if they are impaired', () => {
+    expect(parser.parse({ command: '"echo foo' })).toEqual({ command: '"echo foo' });
+    expect(parser.parse({ command: 'echo foo\'' })).toEqual({ command: 'echo foo\'' });
+    expect(parser.parse({ command: '"echo foo\'' })).toEqual({ command: '"echo foo\'' });
+});

package/src/command.js

@@ -14,6 +14,7 @@ module.exports = class Command {
         this.killProcess = killProcess;
         this.spawn = spawn;
         this.spawnOpts = spawnOpts;
+        this.killed = false;
 
         this.error = new Rx.Subject();
         this.close = new Rx.Subject();
@@ -41,6 +42,7 @@ module.exports = class Command {
                 },
                 index: this.index,
                 exitCode: exitCode === null ? signal : exitCode,
+                killed: this.killed,
             });
         });
         child.stdout && pipeTo(Rx.fromEvent(child.stdout, 'data'), this.stdout);
@@ -50,6 +52,7 @@ module.exports = class Command {
 
     kill(code) {
         if (this.killable) {
+            this.killed = true;
             this.killProcess(this.pid, code);
         }
     }