concurrently 6.5.1 → 7.2.0

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

@@ -1,36 +0,0 @@
-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.js

@@ -1,52 +0,0 @@
-const _ = require('lodash');
-const fs = require('fs');
-
-module.exports = class ExpandNpmWildcard {
-    static readPackage() {
-        try {
-            const json = fs.readFileSync('package.json', { encoding: 'utf-8' });
-            return JSON.parse(json);
-        } catch (e) {
-            return {};
-        }
-    }
-
-    constructor(readPackage = ExpandNpmWildcard.readPackage) {
-        this.readPackage = readPackage;
-    }
-
-    parse(commandInfo) {
-        const [, npmCmd, cmdName, args] = commandInfo.command.match(/(npm|yarn|pnpm) 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}$`);
-        const currentName = commandInfo.name || '';
-
-        return this.scripts
-            .map(script => {
-                const match = script.match(wildcardRegex);
-
-                if (match) {
-                    return Object.assign({}, commandInfo, {
-                        command: `${npmCmd} run ${script}${args}`,
-                        // Will use an empty command name if command has no name and the wildcard match is empty,
-                        // e.g. if `npm:watch-*` matches `npm run watch-`.
-                        name: currentName + match[1],
-                    });
-                }
-            })
-            .filter(Boolean);
-    }
-};

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

@@ -1,104 +0,0 @@
-const ExpandNpmWildcard = require('./expand-npm-wildcard');
-const fs = require('fs');
-
-let parser, readPkg;
-
-beforeEach(() => {
-    readPkg = jest.fn();
-    parser = new ExpandNpmWildcard(readPkg);
-});
-
-describe('ExpandNpmWildcard#readPackage', () => {
-    it('can read package', () => {
-        const expectedPackage = {
-            'name': 'concurrently',
-            'version': '6.4.0',
-        };
-        jest.spyOn(fs, 'readFileSync').mockImplementation((path, options) => {
-            if (path === 'package.json') {
-                return JSON.stringify(expectedPackage);
-            }
-            return null;
-        });
-
-        const actualReadPackage = ExpandNpmWildcard.readPackage();
-        expect(actualReadPackage).toEqual(expectedPackage);
-    });
-
-    it('can handle errors reading package', () => {
-        jest.spyOn(fs, 'readFileSync').mockImplementation(() => {
-            throw new Error('Error reading package');
-        });
-
-        expect(() => ExpandNpmWildcard.readPackage()).not.toThrow();
-        expect(ExpandNpmWildcard.readPackage()).toEqual({});
-    });
-
-});
-
-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: 'bar', command: `${npmCmd} run foo-bar-baz qux` },
-                { name: '', command: `${npmCmd} run foo--baz qux` },
-            ]);
-        });
-
-        it('uses existing command name as prefix to the wildcard match', () => {
-            readPkg.mockReturnValue({
-                scripts: {
-                    'watch-js': '',
-                    'watch-css': '',
-                }
-            });
-
-            expect(parser.parse({
-                name: 'w:',
-                command: `${npmCmd} run watch-*`,
-            })).toEqual([
-                { name: 'w:js', command: `${npmCmd} run watch-js` },
-                { name: 'w:css', command: `${npmCmd} run watch-css` },
-            ]);
-        });
-
-        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.js

@@ -1,12 +0,0 @@
-module.exports = class StripQuotes {
-    parse(commandInfo) {
-        let { command } = commandInfo;
-
-        // Removes the quotes surrounding a command.
-        if (/^"(.+?)"$/.test(command) || /^'(.+?)'$/.test(command)) {
-            command = command.substr(1, command.length - 2);
-        }
-
-        return Object.assign({}, commandInfo, { command });
-    }
-};

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

@@ -1,20 +0,0 @@
-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.spec.js

@@ -1,275 +0,0 @@
-const EventEmitter = require('events');
-const process = require('process');
-const Command = require('./command');
-
-const createProcess = () => {
-    const process = new EventEmitter();
-    process.pid = 1;
-    return process;
-};
-
-const createProcessWithIO = () => {
-    const process = createProcess();
-    return Object.assign(process, {
-        stdout: new EventEmitter(),
-        stderr: new EventEmitter(),
-        stdin: new EventEmitter()
-    });
-};
-
-describe('#start()', () => {
-    it('spawns process with given command and options', () => {
-        const spawn = jest.fn().mockReturnValue(createProcess());
-        const command = new Command({
-            spawn,
-            spawnOpts: { bla: true },
-            command: 'echo foo',
-        });
-        command.start();
-
-        expect(spawn).toHaveBeenCalledTimes(1);
-        expect(spawn).toHaveBeenCalledWith(command.command, { bla: true });
-    });
-
-    it('sets stdin, process and PID', () => {
-        const process = createProcessWithIO();
-        const command = new Command({ spawn: () => process });
-
-        command.start();
-        expect(command.process).toBe(process);
-        expect(command.pid).toBe(process.pid);
-        expect(command.stdin).toBe(process.stdin);
-    });
-
-    it('shares errors to the error stream', done => {
-        const process = createProcess();
-        const command = new Command({ spawn: () => process });
-
-        command.error.subscribe(data => {
-            expect(data).toBe('foo');
-            expect(command.process).toBeUndefined();
-            done();
-        });
-
-        command.start();
-        process.emit('error', 'foo');
-    });
-
-    it('shares start and close timing events to the timing stream', done => {
-        const process = createProcess();
-        const command = new Command({ spawn: () => process });
-
-        const startDate = new Date();
-        const endDate = new Date(startDate.getTime() + 1000);
-        jest.spyOn(Date, 'now')
-            .mockReturnValueOnce(startDate.getTime())
-            .mockReturnValueOnce(endDate.getTime());
-
-        let callCount = 0;
-        command.timer.subscribe(({startDate: actualStartDate, endDate: actualEndDate}) => {
-            switch (callCount) {
-            case 0:
-                expect(actualStartDate).toStrictEqual(startDate);
-                expect(actualEndDate).toBeUndefined();
-                break;
-            case 1:
-                expect(actualStartDate).toStrictEqual(startDate);
-                expect(actualEndDate).toStrictEqual(endDate);
-                done();
-                break;
-            default:
-                throw new Error('Unexpected call count');
-            }
-            callCount++;
-        });
-
-        command.start();
-        process.emit('close', 0, null);
-
-    });
-
-    it('shares start and error timing events to the timing stream', done => {
-        const process = createProcess();
-        const command = new Command({ spawn: () => process });
-
-        const startDate = new Date();
-        const endDate = new Date(startDate.getTime() + 1000);
-        jest.spyOn(Date, 'now')
-            .mockReturnValueOnce(startDate.getTime())
-            .mockReturnValueOnce(endDate.getTime());
-
-        let callCount = 0;
-        command.timer.subscribe(({startDate: actualStartDate, endDate: actualEndDate}) => {
-            switch (callCount) {
-            case 0:
-                expect(actualStartDate).toStrictEqual(startDate);
-                expect(actualEndDate).toBeUndefined();
-                break;
-            case 1:
-                expect(actualStartDate).toStrictEqual(startDate);
-                expect(actualEndDate).toStrictEqual(endDate);
-                done();
-                break;
-            default:
-                throw new Error('Unexpected call count');
-            }
-            callCount++;
-        });
-
-        command.start();
-        process.emit('error', 0, null);
-
-    });
-
-    it('shares closes to the close stream with exit code', done => {
-        const process = createProcess();
-        const command = new Command({ spawn: () => process });
-
-        command.close.subscribe(data => {
-            expect(data.exitCode).toBe(0);
-            expect(data.killed).toBe(false);
-            expect(command.process).toBeUndefined();
-            done();
-        });
-
-        command.start();
-        process.emit('close', 0, null);
-    });
-
-    it('shares closes to the close stream with signal', done => {
-        const process = createProcess();
-        const command = new Command({ spawn: () => process });
-
-        command.close.subscribe(data => {
-            expect(data.exitCode).toBe('SIGKILL');
-            expect(data.killed).toBe(false);
-            done();
-        });
-
-        command.start();
-        process.emit('close', null, 'SIGKILL');
-    });
-
-    it('shares closes to the close stream with timing information', done => {
-        const process1 = createProcess();
-        const command = new Command({ spawn: () => process1 });
-
-        const startDate = new Date();
-        const endDate = new Date(startDate.getTime() + 1000);
-        jest.spyOn(Date, 'now')
-            .mockReturnValueOnce(startDate.getTime())
-            .mockReturnValueOnce(endDate.getTime());
-
-        jest.spyOn(process, 'hrtime')
-            .mockReturnValueOnce([0, 0])
-            .mockReturnValueOnce([1, 1e8]);
-
-        command.close.subscribe(data => {
-            expect(data.timings.startDate).toStrictEqual(startDate);
-            expect(data.timings.endDate).toStrictEqual(endDate);
-            expect(data.timings.durationSeconds).toBe(1.1);
-            done();
-        });
-
-        command.start();
-        process1.emit('close', null, 'SIGKILL');
-    });
-
-    it('shares closes to the close stream with command info and index', done => {
-        const process = createProcess();
-        const commandInfo = {
-            command: 'cmd',
-            name: 'name',
-            prefixColor: 'green',
-            env: { VAR: 'yes' },
-        };
-        const command = new Command(
-            Object.assign({
-                index: 1,
-                spawn: () => process
-            }, commandInfo)
-        );
-
-        command.close.subscribe(data => {
-            expect(data.command).toEqual(commandInfo);
-            expect(data.killed).toBe(false);
-            expect(data.index).toBe(1);
-            done();
-        });
-
-        command.start();
-        process.emit('close', 0, null);
-    });
-
-    it('shares stdout to the stdout stream', done => {
-        const process = createProcessWithIO();
-        const command = new Command({ spawn: () => process });
-
-        command.stdout.subscribe(data => {
-            expect(data.toString()).toBe('hello');
-            done();
-        });
-
-        command.start();
-        process.stdout.emit('data', Buffer.from('hello'));
-    });
-
-    it('shares stderr to the stdout stream', done => {
-        const process = createProcessWithIO();
-        const command = new Command({ spawn: () => process });
-
-        command.stderr.subscribe(data => {
-            expect(data.toString()).toBe('dang');
-            done();
-        });
-
-        command.start();
-        process.stderr.emit('data', Buffer.from('dang'));
-    });
-});
-
-describe('#kill()', () => {
-    let process, killProcess, command;
-    beforeEach(() => {
-        process = createProcess();
-        killProcess = jest.fn();
-        command = new Command({ spawn: () => process, killProcess });
-    });
-
-    it('kills process', () => {
-        command.start();
-        command.kill();
-
-        expect(killProcess).toHaveBeenCalledTimes(1);
-        expect(killProcess).toHaveBeenCalledWith(command.pid, undefined);
-    });
-
-    it('kills process with some signal', () => {
-        command.start();
-        command.kill('SIGKILL');
-
-        expect(killProcess).toHaveBeenCalledTimes(1);
-        expect(killProcess).toHaveBeenCalledWith(command.pid, 'SIGKILL');
-    });
-
-    it('does not try to kill inexistent process', () => {
-        command.start();
-        process.emit('error');
-        command.kill();
-
-        expect(killProcess).not.toHaveBeenCalled();
-    });
-
-    it('marks the command as killed', done => {
-        command.start();
-
-        command.close.subscribe(data => {
-            expect(data.exitCode).toBe(1);
-            expect(data.killed).toBe(true);
-            done();
-        });
-
-        command.kill();
-        process.emit('close', 1, null);
-    });
-});

package/src/completion-listener.js

@@ -1,39 +0,0 @@
-const Rx = require('rxjs');
-const { bufferCount, switchMap, take } = require('rxjs/operators');
-
-module.exports = class CompletionListener {
-    constructor({ successCondition, scheduler }) {
-        this.successCondition = successCondition;
-        this.scheduler = scheduler;
-    }
-
-    isSuccess(exitCodes) {
-        switch (this.successCondition) {
-        /* eslint-disable indent */
-            case 'first':
-                return exitCodes[0] === 0;
-
-            case 'last':
-                return exitCodes[exitCodes.length - 1] === 0;
-
-            default:
-                return exitCodes.every(exitCode => exitCode === 0);
-            /* eslint-enable indent */
-        }
-    }
-
-    listen(commands) {
-        const closeStreams = commands.map(command => command.close);
-        return Rx.merge(...closeStreams)
-            .pipe(
-                bufferCount(closeStreams.length),
-                switchMap(exitInfos =>
-                    this.isSuccess(exitInfos.map(({ exitCode }) => exitCode))
-                        ? Rx.of(exitInfos, this.scheduler)
-                        : Rx.throwError(exitInfos, this.scheduler)
-                ),
-                take(1),
-            )
-            .toPromise();
-    }
-};

package/src/completion-listener.spec.js

@@ -1,89 +0,0 @@
-const { TestScheduler } = require('rxjs/testing');
-
-const createFakeCommand = require('./flow-control/fixtures/fake-command');
-const CompletionListener = require('./completion-listener');
-
-let commands, scheduler;
-beforeEach(() => {
-    commands = [createFakeCommand('foo'), createFakeCommand('bar')];
-    scheduler = new TestScheduler();
-});
-
-const createController = successCondition =>
-    new CompletionListener({
-        successCondition,
-        scheduler
-    });
-
-describe('with default success condition set', () => {
-    it('succeeds if all processes exited with code 0', () => {
-        const result = createController().listen(commands);
-
-        commands[0].close.next({ exitCode: 0 });
-        commands[1].close.next({ exitCode: 0 });
-
-        scheduler.flush();
-
-        return expect(result).resolves.toEqual([{ exitCode: 0 }, { exitCode: 0 }]);
-    });
-
-    it('fails if one of the processes exited with non-0 code', () => {
-        const result = createController().listen(commands);
-
-        commands[0].close.next({ exitCode: 0 });
-        commands[1].close.next({ exitCode: 1 });
-
-        scheduler.flush();
-
-        expect(result).rejects.toEqual([{ exitCode: 0 }, { exitCode: 1 }]);
-    });
-});
-
-describe('with success condition set to first', () => {
-    it('succeeds if first process to exit has code 0', () => {
-        const result = createController('first').listen(commands);
-
-        commands[1].close.next({ exitCode: 0 });
-        commands[0].close.next({ exitCode: 1 });
-
-        scheduler.flush();
-
-        return expect(result).resolves.toEqual([{ exitCode: 0 }, { exitCode: 1 }]);
-    });
-
-    it('fails if first process to exit has non-0 code', () => {
-        const result = createController('first').listen(commands);
-
-        commands[1].close.next({ exitCode: 1 });
-        commands[0].close.next({ exitCode: 0 });
-
-        scheduler.flush();
-
-        return expect(result).rejects.toEqual([{ exitCode: 1 }, { exitCode: 0 }]);
-    });
-});
-
-describe('with success condition set to last', () => {
-    it('succeeds if last process to exit has code 0', () => {
-        const result = createController('last').listen(commands);
-
-        commands[1].close.next({ exitCode: 1 });
-        commands[0].close.next({ exitCode: 0 });
-
-        scheduler.flush();
-
-        return expect(result).resolves.toEqual([{ exitCode: 1 }, { exitCode: 0 }]);
-    });
-
-    it('fails if last process to exit has non-0 code', () => {
-        const result = createController('last').listen(commands);
-
-        commands[1].close.next({ exitCode: 0 });
-        commands[0].close.next({ exitCode: 1 });
-
-        scheduler.flush();
-
-        return expect(result).rejects.toEqual([{ exitCode: 0 }, { exitCode: 1 }]);
-    });
-
-});