1951810458

Build # 1951810458

Build Type

github

Committed by GitHub

Commit Message

Merge c3a06d853 into 49b165516

Pull Request Pull Request #307: Support passthrough of additional arguments to commands via placeholders

Run Details

222 of 232 branches covered (95.69%)

Branch coverage included in aggregate %.

17 of 17 new or added lines in 4 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

407 of 411 relevant lines covered (99.03%)

253.93 hits per line

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

96.1

/src/concurrently.ts

import assert from 'assert';
import _ from 'lodash';
import spawn from 'spawn-command';
import { Writable } from 'stream';
import treeKill from 'tree-kill';
import { CloseEvent, Command, CommandInfo, KillProcess, SpawnCommand } from './command';
import { CommandParser } from './command-parser/command-parser';
import { ExpandArguments } from './command-parser/expand-arguments';
import { ExpandNpmShortcut } from './command-parser/expand-npm-shortcut';
import { ExpandNpmWildcard } from './command-parser/expand-npm-wildcard';
import { StripQuotes } from './command-parser/strip-quotes';
import { CompletionListener, SuccessCondition } from './completion-listener';
import { FlowController } from './flow-control/flow-controller';
import { getSpawnOpts } from './get-spawn-opts';
import { Logger } from './logger';
import { OutputWriter } from './output-writer';

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

/**
 * A command that is to be passed into `concurrently()`.
 * If value is a string, then that's the command's command line.
 * Fine grained options can be defined by using the object format.
 */
export type ConcurrentlyCommandInput = string | Partial<CommandInfo>;

export type ConcurrentlyResult = {
    /**
     * All commands created and ran by concurrently.
     */
     commands: Command[],

    /**
     * A promise that resolves when concurrently ran successfully according to the specified
     * success condition, or reject otherwise.
     *
     * Both the resolved and rejected value is the list of all command's close events.
     */
    result: Promise<CloseEvent[]>,
};

export type ConcurrentlyOptions = {
    logger?: Logger,

    /**
     * Which stream should the commands output be written to.
     */
    outputStream?: Writable,
    group?: boolean,
    prefixColors?: string[],

    /**
     * Maximum number of commands to run at once.
     *
     * If undefined, then all processes will start in parallel.
     * Setting this value to 1 will achieve sequential running.
     */
    maxProcesses?: number,

    /**
     * Whether commands should be spawned in raw mode.
     * Defaults to false.
     */
    raw?: boolean,

    /**
     * The current working directory of commands which didn't specify one.
     * Defaults to `process.cwd()`.
     */
    cwd?: string,

    /**
     * @see CompletionListener
     */
    successCondition?: SuccessCondition,

    /**
     * Which flow controllers should be applied on commands spawned by concurrently.
     * Defaults to an empty array.
     */
    controllers: FlowController[],

    /**
     * A function that will spawn commands.
     * Defaults to the `spawn-command` module.
     */
    spawn: SpawnCommand,

    /**
     * A function that will kill processes.
     * Defaults to the `tree-kill` module.
     */
    kill: KillProcess,

    /**
     * Passthrough additional arguments to commands (accessible via placeholders) instead of treating them as commands.
     */
    passthroughArguments?: boolean,
};

/**
 * Core concurrently functionality -- spawns the given commands concurrently and
 * returns the commands themselves + the result according to the specified success condition.
 *
 * @see CompletionListener
 */
export function concurrently(
    baseCommands: ConcurrentlyCommandInput[],
    baseOptions?: Partial<ConcurrentlyOptions>,
): ConcurrentlyResult {
    assert.ok(Array.isArray(baseCommands), '[concurrently] commands should be an array');
    assert.notStrictEqual(baseCommands.length, 0, '[concurrently] no commands provided');

    const options = _.defaults(baseOptions, defaults);

    const commandParsers: CommandParser[] = [
        new StripQuotes(),
        new ExpandNpmShortcut(),
        new ExpandNpmWildcard(),
    ];

    if (options.passthroughArguments) {
        commandParsers.push(new ExpandArguments());
    }

    let lastColor = '';
    let commands = _(baseCommands)
        .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,
                prefixColor: lastColor,
            }, command), getSpawnOpts({
                raw: options.raw,
                env: command.env,
                cwd: command.cwd || options.cwd,
            }), options.spawn, options.kill);
        })
        .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;


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

    const commandsLeft = commands.slice();
    const maxProcesses = Math.max(1, Number(options.maxProcesses) || commandsLeft.length);
    for (let i = 0; i < maxProcesses; i++) {
        maybeRunMore(commandsLeft);
    }

    const result = new CompletionListener({ successCondition: options.successCondition })
        .listen(commands)
        .finally(() => {
            handleResult.onFinishCallbacks.forEach((onFinish) => onFinish());
        });

    return {
        result,
        commands,
    };
};

function mapToCommandInfo(command: ConcurrentlyCommandInput): CommandInfo {
    if (typeof command === 'string') {
        return {
            command,
            name: '',
            env: {},
            cwd: '',
            additionalArguments: [],
        };
    }

    return Object.assign({
        command: command.command,
        name: command.name || '',
        env: command.env || {},
        cwd: command.cwd || '',
        additionalArguments: command.additionalArguments || [],
    }, command.prefixColor ? {
        prefixColor: command.prefixColor,
    } : {});
}

function parseCommand(command: CommandInfo, parsers: CommandParser[]) {
    return parsers.reduce(
        (commands, parser) => _.flatMap(commands, command => parser.parse(command)),
        _.castArray(command),
    );
}

function maybeRunMore(commandsLeft: Command[]) {
    const command = commandsLeft.shift();
    if (!command) {
        return;
    }

    command.start();
    command.close.subscribe(() => {
        maybeRunMore(commandsLeft);
    });
}

1	import assert from 'assert';	12✔
2	import _ from 'lodash';	12✔
3	import spawn from 'spawn-command';	12✔
4	import { Writable } from 'stream';
5	import treeKill from 'tree-kill';	12✔
6	import { CloseEvent, Command, CommandInfo, KillProcess, SpawnCommand } from './command';	12✔
7	import { CommandParser } from './command-parser/command-parser';
8	import { ExpandArguments } from './command-parser/expand-arguments';	12✔
9	import { ExpandNpmShortcut } from './command-parser/expand-npm-shortcut';	12✔
10	import { ExpandNpmWildcard } from './command-parser/expand-npm-wildcard';	12✔
11	import { StripQuotes } from './command-parser/strip-quotes';	12✔
12	import { CompletionListener, SuccessCondition } from './completion-listener';	12✔
13	import { FlowController } from './flow-control/flow-controller';
14	import { getSpawnOpts } from './get-spawn-opts';	12✔
15	import { Logger } from './logger';
16	import { OutputWriter } from './output-writer';	12✔
17
18	const defaults: ConcurrentlyOptions = {	12✔
19	spawn,
20	kill: treeKill,
21	raw: false,
22	controllers: [],
23	cwd: undefined,
24	};
25
26	/**
27	* A command that is to be passed into `concurrently()`.
28	* If value is a string, then that's the command's command line.
29	* Fine grained options can be defined by using the object format.
30	*/
31	export type ConcurrentlyCommandInput = string \| Partial<CommandInfo>;
32
33	export type ConcurrentlyResult = {
34	/**
35	* All commands created and ran by concurrently.
36	*/
37	commands: Command[],
38
39	/**
40	* A promise that resolves when concurrently ran successfully according to the specified
41	* success condition, or reject otherwise.
42	*
43	* Both the resolved and rejected value is the list of all command's close events.
44	*/
45	result: Promise<CloseEvent[]>,
46	};
47
48	export type ConcurrentlyOptions = {
49	logger?: Logger,
50
51	/**
52	* Which stream should the commands output be written to.
53	*/
54	outputStream?: Writable,
55	group?: boolean,
56	prefixColors?: string[],
57
58	/**
59	* Maximum number of commands to run at once.
60	*
61	* If undefined, then all processes will start in parallel.
62	* Setting this value to 1 will achieve sequential running.
63	*/
64	maxProcesses?: number,
65
66	/**
67	* Whether commands should be spawned in raw mode.
68	* Defaults to false.
69	*/
70	raw?: boolean,
71
72	/**
73	* The current working directory of commands which didn't specify one.
74	* Defaults to `process.cwd()`.
75	*/
76	cwd?: string,
77
78	/**
79	* @see CompletionListener
80	*/
81	successCondition?: SuccessCondition,
82
83	/**
84	* Which flow controllers should be applied on commands spawned by concurrently.
85	* Defaults to an empty array.
86	*/
87	controllers: FlowController[],
88
89	/**
90	* A function that will spawn commands.
91	* Defaults to the `spawn-command` module.
92	*/
93	spawn: SpawnCommand,
94
95	/**
96	* A function that will kill processes.
97	* Defaults to the `tree-kill` module.
98	*/
99	kill: KillProcess,
100
101	/**
102	* Passthrough additional arguments to commands (accessible via placeholders) instead of treating them as commands.
103	*/
104	passthroughArguments?: boolean,
105	};
106
107	/**
108	* Core concurrently functionality -- spawns the given commands concurrently and
109	* returns the commands themselves + the result according to the specified success condition.
110	*
111	* @see CompletionListener
112	*/
113	export function concurrently(	12✔
114	baseCommands: ConcurrentlyCommandInput[],
115	baseOptions?: Partial<ConcurrentlyOptions>,
116	): ConcurrentlyResult {
117	assert.ok(Array.isArray(baseCommands), '[concurrently] commands should be an array');	168✔
118	assert.notStrictEqual(baseCommands.length, 0, '[concurrently] no commands provided');	156✔
119
120	const options = _.defaults(baseOptions, defaults);	144✔
121
122	const commandParsers: CommandParser[] = [	144✔
123	new StripQuotes(),
124	new ExpandNpmShortcut(),
125	new ExpandNpmWildcard(),
126	];
127
128	if (options.passthroughArguments) {	144✔
129	commandParsers.push(new ExpandArguments());	12✔
130	}
131
132	let lastColor = '';	144✔
133	let commands = _(baseCommands)	144✔
134	.map(mapToCommandInfo)
135	.flatMap(command => parseCommand(command, commandParsers))	372✔
136	.map((command, index) => {
137	// Use documented behaviour of repeating last color when specifying more commands than colors
138	lastColor = options.prefixColors && options.prefixColors[index] \|\| lastColor;	372✔
139	return new Command(Object.assign({	372✔
140	index,
141	prefixColor: lastColor,
142	}, command), getSpawnOpts({
143	raw: options.raw,
144	env: command.env,
145	cwd: command.cwd \|\| options.cwd,	732✔
146	}), options.spawn, options.kill);
147	})
148	.value();
149
150	const handleResult = options.controllers.reduce(	144✔
151	({ commands: prevCommands, onFinishCallbacks }, controller) => {
152	const { commands, onFinish } = controller.handle(prevCommands);	288✔
153	return {	288✔
154	commands,
155	onFinishCallbacks: _.concat(onFinishCallbacks, onFinish ? [onFinish] : []),	288✔
156	};
157	},
158	{ commands, onFinishCallbacks: [] },
159	);
160	commands = handleResult.commands;	144✔
161
162
163	if (options.logger) {	144!
UNCOV 164	const outputWriter = new OutputWriter({	×
165	outputStream: options.outputStream,
166	group: options.group,
167	commands,
168	});
UNCOV 169	options.logger.output.subscribe(({command, text}) => outputWriter.write(command, text));	×
170	}
171
172	const commandsLeft = commands.slice();	144✔
173	const maxProcesses = Math.max(1, Number(options.maxProcesses) \|\| commandsLeft.length);	144✔
174	for (let i = 0; i < maxProcesses; i++) {	144✔
175	maybeRunMore(commandsLeft);	336✔
176	}
177
178	const result = new CompletionListener({ successCondition: options.successCondition })	144✔
179	.listen(commands)
180	.finally(() => {
181	handleResult.onFinishCallbacks.forEach((onFinish) => onFinish());	24✔
182	});
183
184	return {	144✔
185	result,
186	commands,
187	};
188	};
189
190	function mapToCommandInfo(command: ConcurrentlyCommandInput): CommandInfo {
191	if (typeof command === 'string') {	372✔
192	return {	192✔
193	command,
194	name: '',
195	env: {},
196	cwd: '',
197	additionalArguments: [],
198	};
199	}
200
201	return Object.assign({	180✔
202	command: command.command,
203	name: command.name \|\| '',	348✔
204	env: command.env \|\| {},	288✔
205	cwd: command.cwd \|\| '',	348✔
206	additionalArguments: command.additionalArguments \|\| [],	264✔
207	}, command.prefixColor ? {	180✔
208	prefixColor: command.prefixColor,
209	} : {});
210	}
211
212	function parseCommand(command: CommandInfo, parsers: CommandParser[]) {
213	return parsers.reduce(	372✔
214	(commands, parser) => _.flatMap(commands, command => parser.parse(command)),	1,164✔
215	_.castArray(command),
216	);
217	}
218
219	function maybeRunMore(commandsLeft: Command[]) {
220	const command = commandsLeft.shift();	396✔
221	if (!command) {	396✔
222	return;	24✔
223	}
224
225	command.start();	372✔
226	command.close.subscribe(() => {	372✔
227	maybeRunMore(commandsLeft);	60✔
228	});
229	}

open-cli-tools / concurrently / 1951810458

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