concurrently 4.0.1 → 5.0.0

package/.travis.yml

@@ -1,8 +1,11 @@
 language: node_js
 node_js:
+  - 12
   - 10
   - 8
   - 6
 script:
   - npm test
   - npm run lint
+after_success:
+  - npm run report-coverage

package/.vscode/settings.json

@@ -1,5 +1,6 @@
 {
     "eslint.enable": true,
     "jest.autoEnable": true,
-    "jest.showCoverageOnLoad": true
+    "jest.showCoverageOnLoad": true,
+    "editor.rulers": [100]
 }

package/CONTRIBUTING.md

@@ -6,7 +6,6 @@ updated.
 
 **Pull requests:** You don't need to bump version numbers or modify anything related to releasing. That stuff is fully automated, just write the functionality.
 
-
 # Maintaining
 
 ## Test
@@ -14,11 +13,9 @@ updated.
 Tests can be run with command:
 
 ```bash
-mocha
+npm run test
 ```
 
-You need to have *mocha* installed globally with `npm install -g mocha`.
-
 ## Release
 
 * Commit all changes

package/README.md

@@ -147,7 +147,7 @@ Prefix styling
                           prefix when it is set to "command"
                                                           [number] [default: 10]
   -t, --timestamp-format  Specify the timestamp in moment/date-fns format.
-                                   [string] [default: "YYYY-MM-DD HH:mm:ss.SSS"]
+                                   [string] [default: "yyyy-MM-dd HH:mm:ss.SSS"]
 
 Input handling
   -i, --handle-input      Whether input should be forwarded to the child
@@ -225,30 +225,30 @@ For more details, visit https://github.com/kimmobrunfeldt/concurrently
 concurrently can be used programmatically by using the API documented below:
 
 ### `concurrently(commands[, options])`
-- `commands`: an array of either strings (containing the commands to run) or objects 
+- `commands`: an array of either strings (containing the commands to run) or objects
   with the shape `{ command, name, prefixColor }`.
 - `options` (optional): an object containing any of the below:
-    - `defaultInputTarget`: the default input target when reading from `inputStream`. 
+    - `defaultInputTarget`: the default input target when reading from `inputStream`.
     Default: `0`.
-    - `inputStream`: a [`Readable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_readable_streams) 
+    - `inputStream`: a [`Readable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_readable_streams)
     to read the input from, eg `process.stdin`.
-    - `killOthers`: an array of exitting conditions that will cause a process to kill others.  
+    - `killOthers`: an array of exitting conditions that will cause a process to kill others.
     Can contain any of `success` or `failure`.
     - `outputStream`: a [`Writable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_writable_streams)
     to write logs to. Default: `process.stdout`.
-    - `prefix`: the prefix type to use when logging processes output.  
-      Possible values: `index`, `pid`, `time`, `command`, `name`, `none`, or a template (eg `[{time} process: {pid}]`).  
+    - `prefix`: the prefix type to use when logging processes output.
+      Possible values: `index`, `pid`, `time`, `command`, `name`, `none`, or a template (eg `[{time} process: {pid}]`).
       Default: the name of the process, or its index if no name is set.
     - `prefixLength`: how many characters to show when prefixing with `command`. Default: `10`
     - `raw`: whether raw mode should be used, meaning strictly process output will
     be logged, without any prefixes, colouring or extra stuff.
     - `successCondition`: the condition to consider the run was successful.
-    If `first`, only the first process will make up the success of the run; if `last`, the last.  
+    If `first`, only the first process to exit will make up the success of the run; if `last`, the last process that exits will determine whether the run succeeds.
     Anything else means all processes should exit successfully.
     - `restartTries`: how many attempts to restart a process that dies will be made. Default: `0`.
     - `restartDelay`: how many milliseconds to wait between process restarts. Default: `0`.
-    - `timestampFormat`: a [date-fns/moment format](https://date-fns.org/v1.29.0/docs/format)
-    to use when prefixing with `time`. Default: `YYYY-MM-DD HH:mm:ss.ZZZ`
+    - `timestampFormat`: a [date-fns format](https://date-fns.org/v2.0.1/docs/format)
+    to use when prefixing with `time`. Default: `yyyy-MM-dd HH:mm:ss.ZZZ`
 
 > Returns: a `Promise` that resolves if the run was successful (according to `successCondition` option),
 > or rejects otherwise.
@@ -258,7 +258,7 @@ Example:
 ```js
 const concurrently = require('concurrently');
 concurrently([
-    'npm:watch-*', 
+    'npm:watch-*',
     { command: 'nodemon', name: 'server' }
 ], {
     prefix: 'name',
@@ -282,3 +282,6 @@ concurrently([
     So *null* means the process didn't terminate normally. This will make **concurrent**
     to return non-zero exit code too.
 
+* Does this work with the npm-replacement [yarn](https://github.com/yarnpkg/yarn)?
+
+    Yes! In all examples above, you may replace "`npm`" with "`yarn`".

package/appveyor.yml

@@ -1,5 +1,6 @@
 environment:
   matrix:
+    - nodejs_version: '12'
     - nodejs_version: '10'
     - nodejs_version: '8'
     - nodejs_version: '6'

package/bin/concurrently.js

@@ -8,7 +8,7 @@ const args = yargs
     .usage('$0 [options] <command ...>')
     .help('h')
     .alias('h', 'help')
-    .version('v')
+    .version('v', require('../package.json').version)
     .alias('v', 'V')
     .alias('v', 'version')
     .options({
@@ -154,6 +154,7 @@ concurrently(args._.map((command, index) => {
         : (args.killOthersOnFail ? ['failure'] : []),
     raw: args.raw,
     prefix: args.prefix,
+    prefixLength: args.prefixLength,
     restartDelay: args.restartAfter,
     restartTries: args.restartTries,
     successCondition: args.success,

package/bin/concurrently.spec.js

@@ -13,7 +13,12 @@ const createKillMessage = prefix => new RegExp(
 
 const run = args => {
     const child = spawn('node ./concurrently.js ' + args, {
-        cwd: __dirname
+        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({
@@ -207,6 +212,26 @@ describe('--prefix', () => {
     });
 });
 
+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"');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "concurrently",
-  "version": "4.0.1",
+  "version": "5.0.0",
   "description": "Run commands concurrently",
   "main": "index.js",
   "bin": {
@@ -11,6 +11,7 @@
   },
   "scripts": {
     "lint": "eslint . --ignore-path .gitignore",
+    "report-coverage": "cat coverage/lcov.info | coveralls",
     "test": "jest"
   },
   "repository": {
@@ -28,19 +29,20 @@
   "author": "Kimmo Brunfeldt",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^2.4.1",
-    "date-fns": "^1.23.0",
-    "lodash": "^4.17.10",
+    "chalk": "^2.4.2",
+    "date-fns": "^2.0.1",
+    "lodash": "^4.17.15",
     "read-pkg": "^4.0.1",
-    "rxjs": "6.2.2",
+    "rxjs": "^6.5.2",
     "spawn-command": "^0.0.2-1",
     "supports-color": "^4.5.0",
-    "tree-kill": "^1.1.0",
-    "yargs": "^12.0.1"
+    "tree-kill": "^1.2.1",
+    "yargs": "^12.0.5"
   },
   "devDependencies": {
-    "eslint": "^5.4.0",
-    "jest": "^23.5.0",
+    "coveralls": "^3.0.4",
+    "eslint": "^5.16.0",
+    "jest": "^24.8.0",
     "jest-create-mock-instance": "^1.1.0"
   },
   "jest": {

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

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

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

@@ -9,25 +9,28 @@ it('returns same command if no npm: prefix is present', () => {
     expect(parser.parse(commandInfo)).toBe(commandInfo);
 });
 
-describe('with npm: prefix', () => {
-    it('expands to "npm run <script> <args>"', () => {
-        const commandInfo = {
-            name: 'echo',
-            command: 'npm:foo -- bar'
-        };
-        expect(parser.parse(commandInfo)).toEqual({
-            name: 'echo',
-            command: 'npm run foo -- bar'
+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: 'npm:foo -- bar'
-        };
-        expect(parser.parse(commandInfo)).toEqual({
-            name: 'foo',
-            command: 'npm 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

@@ -7,7 +7,7 @@ module.exports = class ExpandNpmWildcard {
     }
 
     parse(commandInfo) {
-        const [, cmdName, args] = commandInfo.command.match(/npm run (\S+)([^&]*)/) || [];
+        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,
@@ -27,7 +27,7 @@ module.exports = class ExpandNpmWildcard {
         return this.scripts
             .filter(script => wildcardRegex.test(script))
             .map(script => Object.assign({}, commandInfo, {
-                command: `npm run ${script}${args}`,
+                command: `${npmCmd} run ${script}${args}`,
                 name: script
             }));
     }

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

@@ -31,24 +31,28 @@ it('expands to nothing if no scripts exist in package.json', () => {
     expect(parser.parse({ command: 'npm run foo-*-baz qux' })).toEqual([]);
 });
 
-it('expands to all scripts matching pattern', () => {
-    readPkg.mockReturnValue({
-        scripts: {
-            'foo-bar-baz': '',
-            'foo--baz': '',
-        }
+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);
+        });
     });
-
-    expect(parser.parse({ command: 'npm run foo-*-baz qux' })).toEqual([
-        { name: 'foo-bar-baz', command: 'npm run foo-bar-baz qux' },
-        { name: 'foo--baz', command: 'npm run foo--baz qux' },
-    ]);
-});
-
-it('caches scripts upon calls', () => {
-    readPkg.mockReturnValue({});
-    parser.parse({ command: 'npm run foo-*-baz qux' });
-    parser.parse({ command: 'npm run foo-*-baz qux' });
-
-    expect(readPkg).toHaveBeenCalledTimes(1);
-});
+}

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

@@ -3,7 +3,7 @@ module.exports = class StripQuotes {
         let { command } = commandInfo;
 
         // Removes the quotes surrounding a command.
-        if (command[0] === '"' || command[0] === '\'') {
+        if (/^"(.+?)"$/.test(command) || /^'(.+?)'$/.test(command)) {
             command = command.substr(1, command.length - 2);
         }
 

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

@@ -12,3 +12,9 @@ it('strips single quotes', () => {
 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/defaults.js

@@ -22,6 +22,6 @@ module.exports = {
     restartDelay: 0,
     // Condition of success for concurrently itself.
     success: 'all',
-    // Refer to https://date-fns.org/v1.29.0/docs/format
-    timestampFormat: 'YYYY-MM-DD HH:mm:ss.SSS'
+    // Refer to https://date-fns.org/v2.0.1/docs/format
+    timestampFormat: 'yyyy-MM-dd HH:mm:ss.SSS'
 };

package/src/flow-control/kill-on-signal.js

@@ -8,7 +8,7 @@ module.exports = class KillOnSignal {
 
     handle(commands) {
         let caughtSignal;
-        ['SIGINT', 'SIGTERM'].forEach(signal => {
+        ['SIGINT', 'SIGTERM', 'SIGHUP'].forEach(signal => {
             this.process.on(signal, () => {
                 caughtSignal = signal;
                 commands.forEach(command => command.kill(signal));

package/src/flow-control/kill-on-signal.spec.js

@@ -13,6 +13,16 @@ beforeEach(() => {
     controller = new KillOnSignal({ process });
 });
 
+it('returns commands that keep non-close streams from original commands', () => {
+    const newCommands = controller.handle(commands);
+    newCommands.forEach((newCommand, i) => {
+        expect(newCommand.close).not.toBe(commands[i].close);
+        expect(newCommand.error).toBe(commands[i].error);
+        expect(newCommand.stdout).toBe(commands[i].stdout);
+        expect(newCommand.stderr).toBe(commands[i].stderr);
+    });
+});
+
 it('returns commands that map SIGINT to exit code 0', () => {
     const newCommands = controller.handle(commands);
     expect(newCommands).not.toBe(commands);
@@ -29,6 +39,18 @@ it('returns commands that map SIGINT to exit code 0', () => {
     expect(callback).toHaveBeenCalledWith(0);
 });
 
+it('returns commands that keep non-SIGINT exit codes', () => {
+    const newCommands = controller.handle(commands);
+    expect(newCommands).not.toBe(commands);
+    expect(newCommands).toHaveLength(commands.length);
+
+    const callback = jest.fn();
+    newCommands[0].close.subscribe(callback);
+    commands[0].close.next(1);
+
+    expect(callback).toHaveBeenCalledWith(1);
+});
+
 it('kills all commands on SIGINT', () => {
     controller.handle(commands);
     process.emit('SIGINT');
@@ -46,3 +68,12 @@ it('kills all commands on SIGTERM', () => {
     expect(commands[0].kill).toHaveBeenCalledWith('SIGTERM');
     expect(commands[1].kill).toHaveBeenCalledWith('SIGTERM');
 });
+
+it('kills all commands on SIGHUP', () => {
+    controller.handle(commands);
+    process.emit('SIGHUP');
+
+    expect(process.listenerCount('SIGHUP')).toBe(1);
+    expect(commands[0].kill).toHaveBeenCalledWith('SIGHUP');
+    expect(commands[1].kill).toHaveBeenCalledWith('SIGHUP');
+});

package/src/flow-control/restart-process.spec.js

@@ -116,4 +116,14 @@ describe('returned commands', () => {
         // 1 failure from commands[0], 1 success from commands[1]
         expect(callback).toHaveBeenCalledTimes(2);
     });
+
+    it('keep non-close streams from original commands', () => {
+        const newCommands = controller.handle(commands);
+        newCommands.forEach((newCommand, i) => {
+            expect(newCommand.close).not.toBe(commands[i].close);
+            expect(newCommand.error).toBe(commands[i].error);
+            expect(newCommand.stdout).toBe(commands[i].stdout);
+            expect(newCommand.stderr).toBe(commands[i].stderr);
+        });
+    });
 });

package/src/logger.spec.js

@@ -111,7 +111,7 @@ describe('#logCommandText()', () => {
     });
 
     it('logs with prefixFormat set to time (with timestampFormat)', () => {
-        const logger = createLogger({ prefixFormat: 'time', timestampFormat: 'YYYY' });
+        const logger = createLogger({ prefixFormat: 'time', timestampFormat: 'yyyy' });
         logger.logCommandText('foo', {});
 
         const year = new Date().getFullYear();