2293270110

Build Type

push

github

Committed by GitHub

Commit Message

Support passthrough of additional arguments to commands via placeholders (#307)

Run Details

217 of 227 branches covered (95.59%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

408 of 412 relevant lines covered (99.03%)

82.33 hits per line

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

96.0

/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,

    /**
     * Whether the output should be ordered as if the commands were run sequentially.
     */
    group?: boolean,

    /**
     * Comma-separated list of chalk colors to use on prefixes.
     */
    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,

    /**
     * List of additional arguments passed that will get replaced in each command.
     * If not defined, no argument replacing will happen.
     *
     * @see ExpandArguments
     */
    additionalArguments?: string[],
};

/**
 * 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.additionalArguments) {
        commandParsers.push(new ExpandArguments(options.additionalArguments));
    }

    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: '',
        };
    }

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

open-cli-tools / concurrently / 2293270110

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