concurrently 3.6.0 → 4.1.0

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

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

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

@@ -0,0 +1,14 @@
+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' });
+});

package/src/command.js

@@ -0,0 +1,50 @@
+const Rx = require('rxjs');
+
+module.exports = class Command {
+    get killable() {
+        return !!this.process;
+    }
+
+    constructor({ index, name, command, prefixColor, killProcess, spawn, spawnOpts }) {
+        this.index = index;
+        this.name = name;
+        this.command = command;
+        this.prefixColor = prefixColor;
+        this.killProcess = killProcess;
+        this.spawn = spawn;
+        this.spawnOpts = spawnOpts;
+
+        this.error = new Rx.Subject();
+        this.close = new Rx.Subject();
+        this.stdout = new Rx.Subject();
+        this.stderr = new Rx.Subject();
+    }
+
+    start() {
+        const child = this.spawn(this.command, this.spawnOpts);
+        this.process = child;
+        this.pid = child.pid;
+
+        Rx.fromEvent(child, 'error').subscribe(event => {
+            this.process = undefined;
+            this.error.next(event);
+        });
+        Rx.fromEvent(child, 'close').subscribe(([exitCode, signal]) => {
+            this.process = undefined;
+            this.close.next(exitCode === null ? signal : exitCode);
+        });
+        child.stdout && pipeTo(Rx.fromEvent(child.stdout, 'data'), this.stdout);
+        child.stderr && pipeTo(Rx.fromEvent(child.stderr, 'data'), this.stderr);
+        this.stdin = child.stdin;
+    }
+
+    kill(code) {
+        if (this.killable) {
+            this.killProcess(this.pid, code);
+        }
+    }
+};
+
+function pipeTo(stream, subject) {
+    stream.subscribe(event => subject.next(event));
+}

package/src/command.spec.js

@@ -0,0 +1,142 @@
+const EventEmitter = require('events');
+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 closes to the close stream with exit code', done => {
+        const process = createProcess();
+        const command = new Command({ spawn: () => process });
+
+        command.close.subscribe(data => {
+            expect(data).toBe(0);
+            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).toBe('SIGKILL');
+            done();
+        });
+
+        command.start();
+        process.emit('close', null, 'SIGKILL');
+    });
+
+    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();
+    });
+});

package/src/completion-listener.js

@@ -0,0 +1,35 @@
+const Rx = require('rxjs');
+const { bufferCount, map, switchMap, take } = require('rxjs/operators');
+
+module.exports = class CompletionListener {
+    constructor({ successCondition, scheduler }) {
+        this.successCondition = successCondition;
+        this.scheduler = scheduler;
+    }
+
+    listen(commands) {
+        const closeStreams = commands.map(command => command.close);
+        const allClosed = Rx.zip(...closeStreams);
+        return Rx.merge(...closeStreams).pipe(
+            bufferCount(closeStreams.length),
+            map(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 */
+                }
+            }),
+            switchMap(success => success
+                ? Rx.of(null, this.scheduler)
+                : Rx.throwError(new Error(), this.scheduler)),
+            take(1)
+        ).toPromise();
+    }
+};

package/src/completion-listener.spec.js

@@ -0,0 +1,88 @@
+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(0);
+        commands[1].close.next(0);
+
+        scheduler.flush();
+
+        return expect(result).resolves.toBeNull();
+    });
+
+    it('fails if one of the processes exited with non-0 code', () => {
+        const result = createController().listen(commands);
+
+        commands[0].close.next(0);
+        commands[1].close.next(1);
+
+        scheduler.flush();
+
+        expect(result).rejects.toThrowError();
+    });
+});
+
+
+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(0);
+        commands[0].close.next(1);
+
+        scheduler.flush();
+
+        return expect(result).resolves.toBeNull();
+    });
+
+    it('fails if first process to exit has non-0 code', () => {
+        const result = createController('first').listen(commands);
+
+        commands[1].close.next(1);
+        commands[0].close.next(0);
+
+        scheduler.flush();
+
+        return expect(result).rejects.toThrowError();
+    });
+});
+
+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(1);
+        commands[0].close.next(0);
+
+        scheduler.flush();
+
+        return expect(result).resolves.toBeNull();
+    });
+
+    it('fails if last process to exit has non-0 code', () => {
+        const result = createController('last').listen(commands);
+
+        commands[1].close.next(0);
+        commands[0].close.next(1);
+
+        scheduler.flush();
+
+        return expect(result).rejects.toThrowError();
+    });
+});

package/src/concurrently.js

@@ -0,0 +1,69 @@
+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: []
+};
+
+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()
+    ];
+
+    const spawnOpts = getSpawnOpts({ raw: options.raw });
+
+    commands = _(commands)
+        .map(mapToCommandInfo)
+        .flatMap(command => parseCommand(command, commandParsers))
+        .map((command, index) => new Command(Object.assign({
+            index,
+            spawnOpts,
+            killProcess: options.kill,
+            spawn: options.spawn,
+        }, command)))
+        .value();
+
+    commands = options.controllers.reduce(
+        (prevCommands, controller) => controller.handle(prevCommands),
+        commands
+    );
+
+    commands.forEach(command => command.start());
+    return new CompletionListener({ successCondition: options.successCondition }).listen(commands);
+};
+
+function mapToCommandInfo(command) {
+    return {
+        command: command.command || command,
+        name: command.name || '',
+        prefixColor: command.prefixColor || '',
+    };
+}
+
+function parseCommand(command, parsers) {
+    return parsers.reduce(
+        (commands, parser) => _.flatMap(commands, command => parser.parse(command)),
+        _.castArray(command)
+    );
+}

package/src/concurrently.spec.js

@@ -0,0 +1,77 @@
+const EventEmitter = require('events');
+const { Subject } = require('rxjs');
+
+const createFakeCommand = require('./flow-control/fixtures/fake-command');
+const concurrently = require('./concurrently');
+
+let spawn, kill, controllers;
+beforeEach(() => {
+    const process = new EventEmitter();
+    process.pid = 1;
+
+    spawn = jest.fn(() => process);
+    kill = jest.fn();
+    controllers = [{ handle: jest.fn(arg => arg) }, { handle: jest.fn(arg => arg) }];
+});
+
+const create = (commands, options = {}) => concurrently(
+    commands,
+    Object.assign(options, { controllers, spawn, kill })
+);
+
+it('fails if commands is not an array', () => {
+    const bomb = () => create('foo');
+    expect(bomb).toThrowError();
+});
+
+it('fails if no commands were provided', () => {
+    const bomb = () => create([]);
+    expect(bomb).toThrowError();
+});
+
+it('spawns all commands', () => {
+    create(['echo', 'kill']);
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({}));
+});
+
+it('runs controllers with the commands', () => {
+    create(['echo', '"echo wrapped"']);
+
+    controllers.forEach(controller => {
+        expect(controller.handle).toHaveBeenCalledWith([
+            expect.objectContaining({ command: 'echo', index: 0 }),
+            expect.objectContaining({ command: 'echo wrapped', index: 1 }),
+        ]);
+    });
+});
+
+it('runs commands with a name or prefix color', () => {
+    create([
+        { command: 'echo', prefixColor: 'red', name: 'foo' },
+        'kill'
+    ]);
+
+    controllers.forEach(controller => {
+        expect(controller.handle).toHaveBeenCalledWith([
+            expect.objectContaining({ command: 'echo', index: 0, name: 'foo', prefixColor: 'red' }),
+            expect.objectContaining({ command: 'kill', index: 1, name: '', prefixColor: '' }),
+        ]);
+    });
+});
+
+it('passes commands wrapped from a controller to the next one', () => {
+    const fakeCommand = createFakeCommand('banana', 'banana');
+    controllers[0].handle.mockReturnValue([fakeCommand]);
+
+    create(['echo']);
+
+    expect(controllers[0].handle).toHaveBeenCalledWith([
+        expect.objectContaining({ command: 'echo', index: 0 })
+    ]);
+
+    expect(controllers[1].handle).toHaveBeenCalledWith([fakeCommand]);
+
+    expect(fakeCommand.start).toHaveBeenCalledTimes(1);
+});

package/src/defaults.js

@@ -0,0 +1,27 @@
+/**
+ * This file is meant to be a shared place for default configs.
+ * It's read by the flow controllers, the executable, etc.
+ *
+ * Refer to tests for the meaning of the different possible values.
+ */
+module.exports = {
+    defaultInputTarget: 0,
+    // Whether process.stdin should be forwarded to child processes
+    handleInput: false,
+    nameSeparator: ',',
+    // Which prefix style to use when logging processes output.
+    prefix: '',
+    // Refer to https://www.npmjs.com/package/chalk
+    prefixColors: 'gray.dim',
+    // How many bytes we'll show on the command prefix
+    prefixLength: 10,
+    raw: false,
+    // Number of attempts of restarting a process, if it exits with non-0 code
+    restartTries: 0,
+    // How many milliseconds concurrently should wait before restarting a process.
+    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'
+};

package/src/flow-control/fixtures/fake-command.js

@@ -0,0 +1,16 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const { Writable } = require('stream');
+const { Subject } = require('rxjs');
+
+module.exports = (name = 'foo', command = 'echo foo', index = 0) => ({
+    index,
+    name,
+    command,
+    close: new Subject(),
+    error: new Subject(),
+    stderr: new Subject(),
+    stdout: new Subject(),
+    stdin: createMockInstance(Writable),
+    start: jest.fn(),
+    kill: jest.fn()
+});

package/src/flow-control/input-handler.js

@@ -0,0 +1,39 @@
+const Rx = require('rxjs');
+const { map } = require('rxjs/operators');
+
+const defaults = require('../defaults');
+
+module.exports = class InputHandler {
+    constructor({ defaultInputTarget, inputStream, logger }) {
+        this.defaultInputTarget = defaultInputTarget || defaults.defaultInputTarget;
+        this.inputStream = inputStream;
+        this.logger = logger;
+    }
+
+    handle(commands) {
+        if (!this.inputStream) {
+            return commands;
+        }
+
+        Rx.fromEvent(this.inputStream, 'data')
+            .pipe(map(data => data.toString()))
+            .subscribe(data => {
+                let [targetId, input] = data.split(':', 2);
+                targetId = input ? targetId : this.defaultInputTarget;
+                input = input || data;
+
+                const command = commands.find(command => (
+                    command.name === targetId ||
+                    command.index.toString() === targetId.toString()
+                ));
+
+                if (command && command.stdin) {
+                    command.stdin.write(input);
+                } else {
+                    this.logger.logGlobalEvent(`Unable to find command ${targetId}, or it has no stdin open\n`);
+                }
+            });
+
+        return commands;
+    }
+};

package/src/flow-control/input-handler.spec.js

@@ -0,0 +1,79 @@
+const EventEmitter = require('events');
+const { createMockInstance } = require('jest-create-mock-instance');
+
+const Logger = require('../logger');
+const createFakeCommand = require('./fixtures/fake-command');
+const InputHandler = require('./input-handler');
+
+let commands, controller, inputStream, logger;
+
+beforeEach(() => {
+    commands = [
+        createFakeCommand('foo', 'echo foo', 0),
+        createFakeCommand('bar', 'echo bar', 1),
+    ];
+    inputStream = new EventEmitter();
+    logger = createMockInstance(Logger);
+    controller = new InputHandler({
+        defaultInputTarget: 0,
+        inputStream,
+        logger
+    });
+});
+
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toBe(commands);
+
+    controller = new InputHandler({ logger });
+    expect(controller.handle(commands)).toBe(commands);
+});
+
+it('forwards input stream to default target ID', () => {
+    controller.handle(commands);
+
+    inputStream.emit('data', Buffer.from('something'));
+
+    expect(commands[0].stdin.write).toHaveBeenCalledTimes(1);
+    expect(commands[0].stdin.write).toHaveBeenCalledWith('something');
+    expect(commands[1].stdin.write).not.toHaveBeenCalled();
+});
+
+it('forwards input stream to target index specified in input', () => {
+    controller.handle(commands);
+
+    inputStream.emit('data', Buffer.from('1:something'));
+
+    expect(commands[0].stdin.write).not.toHaveBeenCalled();
+    expect(commands[1].stdin.write).toHaveBeenCalledTimes(1);
+    expect(commands[1].stdin.write).toHaveBeenCalledWith('something');
+});
+
+it('forwards input stream to target name specified in input', () => {
+    controller.handle(commands);
+
+    inputStream.emit('data', Buffer.from('bar:something'));
+
+    expect(commands[0].stdin.write).not.toHaveBeenCalled();
+    expect(commands[1].stdin.write).toHaveBeenCalledTimes(1);
+    expect(commands[1].stdin.write).toHaveBeenCalledWith('something');
+});
+
+it('logs error if command has no stdin open', () => {
+    commands[0].stdin = null;
+    controller.handle(commands);
+
+    inputStream.emit('data', Buffer.from('something'));
+
+    expect(commands[1].stdin.write).not.toHaveBeenCalled();
+    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Unable to find command 0, or it has no stdin open\n');
+});
+
+it('logs error if command is not found', () => {
+    controller.handle(commands);
+
+    inputStream.emit('data', Buffer.from('foobar:something'));
+
+    expect(commands[0].stdin.write).not.toHaveBeenCalled();
+    expect(commands[1].stdin.write).not.toHaveBeenCalled();
+    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Unable to find command foobar, or it has no stdin open\n');
+});

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

@@ -0,0 +1,29 @@
+const { map } = require('rxjs/operators');
+
+
+module.exports = class KillOnSignal {
+    constructor({ process = global.process } = {}) {
+        this.process = process;
+    }
+
+    handle(commands) {
+        let caughtSignal;
+        ['SIGINT', 'SIGTERM'].forEach(signal => {
+            this.process.on(signal, () => {
+                caughtSignal = signal;
+                commands.forEach(command => command.kill(signal));
+            });
+        });
+
+        return commands.map(command => {
+            const closeStream = command.close.pipe(map(value => {
+                return caughtSignal === 'SIGINT' ? 0 : value;
+            }));
+            return new Proxy(command, {
+                get(target, prop) {
+                    return prop === 'close' ? closeStream : target[prop];
+                }
+            });
+        });
+    }
+};