1298613556

Build Type

github

Committed by GitHub

Commit Message

Merge 8346fc5c2 into 475fb53d4

Pull Request Pull Request #272: Add --group option

Run Details

168 of 170 branches covered (98.82%)

Branch coverage included in aggregate %.

35 of 37 new or added lines in 4 files covered. (94.59%)

2 existing lines in 1 file now uncovered.

302 of 309 relevant lines covered (97.73%)

108.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.52

/src/concurrently.js

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 OutputWriter = require('./output-writer');

const defaults = {
    spawn,
    kill: treeKill,
    raw: false,
    controllers: [],
    cwd: undefined,
};

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,
                }, 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);
    }

    if (options.logger) {
        const outputWriter = new OutputWriter({
            outputStream: options.outputStream,
            group: options.group,
            commands,
        });
        options.logger.observable.subscribe(({command, text}) => outputWriter.write(command, text));
    }

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

1	const assert = require('assert');	9✔
2	const _ = require('lodash');	9✔
3	const spawn = require('spawn-command');	9✔
4	const treeKill = require('tree-kill');	9✔
5
6	const StripQuotes = require('./command-parser/strip-quotes');	9✔
7	const ExpandNpmShortcut = require('./command-parser/expand-npm-shortcut');	9✔
8	const ExpandNpmWildcard = require('./command-parser/expand-npm-wildcard');	9✔
9
10	const CompletionListener = require('./completion-listener');	9✔
11
12	const getSpawnOpts = require('./get-spawn-opts');	9✔
13	const Command = require('./command');	9✔
14	const OutputWriter = require('./output-writer');	9✔
15
16	const defaults = {	9✔
17	spawn,
18	kill: treeKill,
19	raw: false,
20	controllers: [],
21	cwd: undefined,
22	};
23
24	module.exports = (commands, options) => {	9✔
25	assert.ok(Array.isArray(commands), '[concurrently] commands should be an array');	108✔
26	assert.notStrictEqual(commands.length, 0, '[concurrently] no commands provided');	99✔
27
28	options = _.defaults(options, defaults);	90✔
29
30	const commandParsers = [	90✔
31	new StripQuotes(),
32	new ExpandNpmShortcut(),
33	new ExpandNpmWildcard()
34	];
35
36	let lastColor = '';	90✔
37	commands = _(commands)	90✔
38	.map(mapToCommandInfo)
39	.flatMap(command => parseCommand(command, commandParsers))	207✔
40	.map((command, index) => {
41	// Use documented behaviour of repeating last color when specifying more commands than colors
42	lastColor = options.prefixColors && options.prefixColors[index] \|\| lastColor;	207✔
43	return new Command(	207✔
44	Object.assign({
45	index,
46	spawnOpts: getSpawnOpts({
47	raw: options.raw,
48	env: command.env,
49	cwd: command.cwd \|\| options.cwd,	405✔
50	}),
51	prefixColor: lastColor,
52	killProcess: options.kill,
53	spawn: options.spawn,
54	}, command)
55	);
56	})
57	.value();
58
59	const handleResult = options.controllers.reduce(	90✔
60	({ commands: prevCommands, onFinishCallbacks }, controller) => {
61	const { commands, onFinish } = controller.handle(prevCommands);	180✔
62	return {	180✔
63	commands,
64	onFinishCallbacks: _.concat(onFinishCallbacks, onFinish ? [onFinish] : [])	180✔
65	};
66	},
67	{ commands, onFinishCallbacks: [] }
68	);
69	commands = handleResult.commands;	90✔
70
71	const commandsLeft = commands.slice();	90✔
72	const maxProcesses = Math.max(1, Number(options.maxProcesses) \|\| commandsLeft.length);	90✔
73	for (let i = 0; i < maxProcesses; i++) {	90✔
74	maybeRunMore(commandsLeft);	180✔
75	}
76
77	if (options.logger) {	90!
NEW UNCOV 78	const outputWriter = new OutputWriter({	×
79	outputStream: options.outputStream,
80	group: options.group,
81	commands,
82	});
NEW UNCOV 83	options.logger.observable.subscribe(({command, text}) => outputWriter.write(command, text));	×
84	}
85
86	return new CompletionListener({ successCondition: options.successCondition })	90✔
87	.listen(commands)
88	.finally(() => {
89	handleResult.onFinishCallbacks.forEach((onFinish) => onFinish());	18✔
90	});
91	};
92
93	function mapToCommandInfo(command) {
94	return Object.assign({	207✔
95	command: command.command \|\| command,	351✔
96	name: command.name \|\| '',	405✔
97	env: command.env \|\| {},	360✔
98	cwd: command.cwd \|\| '',	405✔
99	}, command.prefixColor ? {	207✔
100	prefixColor: command.prefixColor,
101	} : {});
102	}
103
104	function parseCommand(command, parsers) {
105	return parsers.reduce(	207✔
106	(commands, parser) => _.flatMap(commands, command => parser.parse(command)),	621✔
107	_.castArray(command)
108	);
109	}
110
111	function maybeRunMore(commandsLeft) {
112	const command = commandsLeft.shift();	225✔
113	if (!command) {	225✔
114	return;	18✔
115	}
116
117	command.start();	207✔
118	command.close.subscribe(() => {	207✔
119	maybeRunMore(commandsLeft);	45✔
120	});
121	}

open-cli-tools / concurrently / 1298613556

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous