concurrently 6.5.0 → 7.1.0

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

@@ -1,43 +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}$`);
-
-        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

@@ -1,87 +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: '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

@@ -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 }]);
-    });
-
-});

package/src/concurrently.js

@@ -1,116 +0,0 @@
-const assert = require('assert');
-const _ = require('lodash');
-const spawn = require('spawn-command');
-const treeKill = require('tree-kill');
-
-const StripQuotes = require('./command-parser/strip-quotes');
-const ExpandNpmShortcut = require('./command-parser/expand-npm-shortcut');
-const ExpandNpmWildcard = require('./command-parser/expand-npm-wildcard');
-
-const CompletionListener = require('./completion-listener');
-
-const getSpawnOpts = require('./get-spawn-opts');
-const Command = require('./command');
-
-const defaults = {
-    spawn,
-    kill: treeKill,
-    raw: false,
-    controllers: [],
-    cwd: undefined,
-    timings: false
-};
-
-module.exports = (commands, options) => {
-    assert.ok(Array.isArray(commands), '[concurrently] commands should be an array');
-    assert.notStrictEqual(commands.length, 0, '[concurrently] no commands provided');
-
-    options = _.defaults(options, defaults);
-
-    const commandParsers = [
-        new StripQuotes(),
-        new ExpandNpmShortcut(),
-        new ExpandNpmWildcard()
-    ];
-
-    let lastColor = '';
-    commands = _(commands)
-        .map(mapToCommandInfo)
-        .flatMap(command => parseCommand(command, commandParsers))
-        .map((command, index) => {
-            // Use documented behaviour of repeating last color when specifying more commands than colors
-            lastColor = options.prefixColors && options.prefixColors[index] || lastColor;
-            return new Command(
-                Object.assign({
-                    index,
-                    spawnOpts: getSpawnOpts({
-                        raw: options.raw,
-                        env: command.env,
-                        cwd: command.cwd || options.cwd,
-                    }),
-                    prefixColor: lastColor,
-                    killProcess: options.kill,
-                    spawn: options.spawn,
-                    timings: options.timings,
-                }, command)
-            );
-        })
-        .value();
-
-    const handleResult = options.controllers.reduce(
-        ({ commands: prevCommands, onFinishCallbacks }, controller) => {
-            const { commands, onFinish } = controller.handle(prevCommands);
-            return {
-                commands,
-                onFinishCallbacks: _.concat(onFinishCallbacks, onFinish ? [onFinish] : [])
-            };
-        },
-        { commands, onFinishCallbacks: [] }
-    );
-    commands = handleResult.commands;
-
-    const commandsLeft = commands.slice();
-    const maxProcesses = Math.max(1, Number(options.maxProcesses) || commandsLeft.length);
-    for (let i = 0; i < maxProcesses; i++) {
-        maybeRunMore(commandsLeft);
-    }
-
-    return new CompletionListener({
-        successCondition: options.successCondition,
-    })
-        .listen(commands)
-        .finally(() => {
-            handleResult.onFinishCallbacks.forEach((onFinish) => onFinish());
-        });
-};
-
-function mapToCommandInfo(command) {
-    return Object.assign({
-        command: command.command || command,
-        name: command.name || '',
-        env: command.env || {},
-        cwd: command.cwd || '',
-
-    }, command.prefixColor ? {
-        prefixColor: command.prefixColor,
-    } : {});
-}
-
-function parseCommand(command, parsers) {
-    return parsers.reduce(
-        (commands, parser) => _.flatMap(commands, command => parser.parse(command)),
-        _.castArray(command)
-    );
-}
-
-function maybeRunMore(commandsLeft) {
-    const command = commandsLeft.shift();
-    if (!command) {
-        return;
-    }
-
-    command.start();
-    command.close.subscribe(() => {
-        maybeRunMore(commandsLeft);
-    });
-}