concurrently 3.6.0 → 4.1.0

package/bin/concurrently.spec.js

@@ -0,0 +1,340 @@
+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
+    });
+
+    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('--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 alised 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/bin/epilogue.txt

@@ -0,0 +1,46 @@
+Examples:
+
+ - Output nothing more than stdout+stderr of child processes
+
+     $ $0 --raw "npm run watch-less" "npm run watch-js"
+
+ - Normal output but without colors e.g. when logging to file
+
+     $ $0 --no-color "grunt watch" "http-server" > log
+
+ - Custom prefix
+
+     $ $0 --prefix "{time}-{pid}" "npm run watch" "http-server"
+
+ - Custom names and colored prefixes
+
+     $ $0 --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold" "http-server" "npm run watch"
+
+ - Shortened NPM run commands
+
+     $ $0 npm:watch-node npm:watch-js npm:watch-css
+
+ - Send input to default
+
+     $ $0 --handle-input "nodemon" "npm run watch-js"
+     rs  # Sends rs command to nodemon process
+
+ - Send input to specific child identified by index
+
+     $ $0 --handle-input "npm run watch-js" nodemon
+     1:rs
+
+ - Send input to specific child identified by name
+
+     $ $0 --handle-input -n js,srv "npm run watch-js" nodemon
+     srv:rs
+
+ - Shortened NPM run commands
+
+     $ $0 npm:watch-node npm:watch-js npm:watch-css
+
+ - Shortened NPM run command with wildcard
+
+     $ $0 npm:watch-*
+
+For more details, visit https://github.com/kimmobrunfeldt/concurrently

package/{test/support → bin/fixtures}/read-echo.js

@@ -1,5 +1,3 @@
-'use strict';
-
 process.stdin.on('data', (chunk) => {
     const line = chunk.toString().trim();
     console.log(line);

package/index.js

@@ -0,0 +1,56 @@
+const InputHandler = require('./src/flow-control/input-handler');
+const KillOnSignal = require('./src/flow-control/kill-on-signal');
+const KillOthers = require('./src/flow-control/kill-others');
+const LogError = require('./src/flow-control/log-error');
+const LogExit = require('./src/flow-control/log-exit');
+const LogOutput = require('./src/flow-control/log-output');
+const RestartProcess = require('./src/flow-control/restart-process');
+
+const concurrently = require('./src/concurrently');
+const Logger = require('./src/logger');
+
+module.exports = (commands, options = {}) => {
+    const logger = new Logger({
+        outputStream: options.outputStream || process.stdout,
+        prefixFormat: options.prefix,
+        prefixLength: options.prefixLength,
+        raw: options.raw,
+        timestampFormat: options.timestampFormat,
+    });
+
+    return concurrently(commands, {
+        raw: options.raw,
+        successCondition: options.successCondition,
+        controllers: [
+            new LogError({ logger }),
+            new LogOutput({ logger }),
+            new LogExit({ logger }),
+            new InputHandler({
+                logger,
+                defaultInputTarget: options.defaultInputTarget,
+                inputStream: options.inputStream,
+            }),
+            new KillOnSignal(),
+            new RestartProcess({
+                logger,
+                delay: options.restartDelay,
+                tries: options.restartTries,
+            }),
+            new KillOthers({
+                logger,
+                conditions: options.killOthers
+            })
+        ]
+    });
+};
+
+// Export all flow controllers and the main concurrently function,
+// so that 3rd-parties can use them however they want
+exports.concurrently = concurrently;
+exports.InputHandler = InputHandler;
+exports.KillOnSignal = KillOnSignal;
+exports.KillOthers = KillOthers;
+exports.LogError = LogError;
+exports.LogExit = LogExit;
+exports.LogOutput = LogOutput;
+exports.RestartProcess = RestartProcess;

package/package.json

@@ -1,22 +1,18 @@
 {
   "name": "concurrently",
-  "version": "3.6.0",
+  "version": "4.1.0",
   "description": "Run commands concurrently",
-  "main": "src/main.js",
+  "main": "index.js",
   "bin": {
-    "concurrent": "./src/main.js",
-    "concurrently": "./src/main.js"
+    "concurrently": "./bin/concurrently.js"
   },
   "engines": {
-    "node": ">=4.0.0"
+    "node": ">=6.0.0"
   },
   "scripts": {
-    "lint": "eslint .",
-    "test": "mocha",
-    "echo": "echo",
-    "echo-test": "echo test",
-    "echo-sound-beep": "echo beep",
-    "echo-sound-boop": "echo boop"
+    "lint": "eslint . --ignore-path .gitignore",
+    "report-coverage": "cat coverage/lcov.info | coveralls",
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -32,31 +28,32 @@
   ],
   "author": "Kimmo Brunfeldt",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/kimmobrunfeldt/concurrently/issues"
-  },
-  "homepage": "https://github.com/kimmobrunfeldt/concurrently",
   "dependencies": {
     "chalk": "^2.4.1",
-    "commander": "2.6.0",
     "date-fns": "^1.23.0",
-    "lodash": "^4.5.1",
-    "read-pkg": "^3.0.0",
-    "rx": "2.3.24",
+    "lodash": "^4.17.10",
+    "read-pkg": "^4.0.1",
+    "rxjs": "^6.3.3",
     "spawn-command": "^0.0.2-1",
-    "supports-color": "^3.2.3",
-    "tree-kill": "^1.1.0"
+    "supports-color": "^4.5.0",
+    "tree-kill": "^1.1.0",
+    "yargs": "^12.0.1"
   },
   "devDependencies": {
-    "chai": "^1.10.0",
-    "eslint": "^4.19.1",
-    "mocha": "^2.1.0",
-    "mustache": "^1.0.0",
-    "releasor": "^1.2.1",
-    "semver": "^4.2.0",
-    "shell-quote": "^1.4.3",
-    "shelljs": "^0.3.0",
-    "sinon": "^4.1.3",
-    "string": "^3.0.0"
+    "coveralls": "^3.0.2",
+    "eslint": "^5.4.0",
+    "jest": "^23.5.0",
+    "jest-create-mock-instance": "^1.1.0"
+  },
+  "jest": {
+    "collectCoverage": true,
+    "collectCoverageFrom": [
+      "src/**/*.js"
+    ],
+    "coveragePathIgnorePatterns": [
+      "/fixtures/",
+      "/node_modules/"
+    ],
+    "testEnvironment": "node"
   }
 }

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

@@ -0,0 +1,13 @@
+module.exports = class ExpandNpmShortcut {
+    parse(commandInfo) {
+        const [, npmCmd, cmdName, args] = commandInfo.command.match(/^(npm|yarn):(\S+)(.*)/) || [];
+        if (!cmdName) {
+            return commandInfo;
+        }
+
+        return Object.assign({}, commandInfo, {
+            name: commandInfo.name || cmdName,
+            command: `${npmCmd} run ${cmdName}${args}`
+        });
+    }
+};

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']) {
+    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.js

@@ -0,0 +1,34 @@
+const _ = require('lodash');
+const readPkg = require('read-pkg');
+
+module.exports = class ExpandNpmWildcard {
+    constructor(readPackage = readPkg.sync) {
+        this.readPackage = readPackage;
+    }
+
+    parse(commandInfo) {
+        const [, npmCmd, cmdName, args] = commandInfo.command.match(/(npm|yarn) run (\S+)([^&]*)/) || [];
+        const wildcardPosition = (cmdName || '').indexOf('*');
+
+        // If the regex didn't match an npm script, or it has no wildcard,
+        // then we have nothing to do here
+        if (!cmdName || wildcardPosition === -1) {
+            return commandInfo;
+        }
+
+        if (!this.scripts) {
+            this.scripts = Object.keys(this.readPackage().scripts || {});
+        }
+
+        const preWildcard = _.escapeRegExp(cmdName.substr(0, wildcardPosition));
+        const postWildcard = _.escapeRegExp(cmdName.substr(wildcardPosition + 1));
+        const wildcardRegex = new RegExp(`^${preWildcard}(.*?)${postWildcard}$`);
+
+        return this.scripts
+            .filter(script => wildcardRegex.test(script))
+            .map(script => Object.assign({}, commandInfo, {
+                command: `${npmCmd} run ${script}${args}`,
+                name: script
+            }));
+    }
+};

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']) {
+    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);
+        });
+    });
+}