Add .all property with interleaved stdout and stderr

fixtures/noop-132

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+'use strict';
+// Interleaving the output of stdout and stderr is unpredictable and can't be
+// expressed as a test. What I've tried so far to make it predictable:
+// - process.stdout._handle.setBlocking(true)
+// - process.stdout.once('drain', () => process.stderr.write('2'));
+// - process.stdout.write('1', () => process.stderr.write('2'));
+// - await delay() between calls; it works but with varying ms, based on load
+// - console.log/error
+
+process.stdout.write('1');
+process.stderr.write('3');
+
+setTimeout(() => {
+	process.stdout.write('2');
+}, 1000);

index.js

@@ -7,6 +7,7 @@ const stripFinalNewline = require('strip-final-newline');
 const npmRunPath = require('npm-run-path');
 const isStream = require('is-stream');
 const _getStream = require('get-stream');
+const mergeStream = require('merge-stream');
 const pFinally = require('p-finally');
 const onExit = require('signal-exit');
 const errname = require('./lib/errname');
@@ -91,6 +92,24 @@ function handleShell(fn, command, options) {
 	return fn(command, {...options, shell: true});
 }
 
+function makeAllStream(spawned) {
+	if (!spawned.stdout && !spawned.stderr) {
+		return null;
+	}
+
+	const mixed = mergeStream();
+
+	if (spawned.stdout) {
+		mixed.add(spawned.stdout);
+	}
+
+	if (spawned.stderr) {
+		mixed.add(spawned.stderr);
+	}
+
+	return mixed;
+}
+
 function getStream(process, stream, {encoding, buffer, maxBuffer}) {
 	if (!process[stream]) {
 		return null;
@@ -261,17 +280,24 @@ module.exports = (command, args, options) => {
 		if (spawned.stderr) {
 			spawned.stderr.destroy();
 		}
+
+		if (spawned.all) {
+			spawned.all.destroy();
+		}
 	}
 
 	// TODO: Use native "finally" syntax when targeting Node.js 10
 	const handlePromise = () => pFinally(Promise.all([
 		processDone,
 		getStream(spawned, 'stdout', {encoding, buffer, maxBuffer}),
-		getStream(spawned, 'stderr', {encoding, buffer, maxBuffer})
+		getStream(spawned, 'stderr', {encoding, buffer, maxBuffer}),
+		getStream(spawned, 'all', {encoding, buffer, maxBuffer: maxBuffer * 2})
+
 	]).then(results => { // eslint-disable-line promise/prefer-await-to-then
 		const result = results[0];
 		result.stdout = results[1];
 		result.stderr = results[2];
+		result.all = results[3];
 
 		if (result.error || result.code !== 0 || result.signal !== null) {
 			const error = makeError(result, {
@@ -295,6 +321,7 @@ module.exports = (command, args, options) => {
 		return {
 			stdout: handleOutput(parsed.options, result.stdout),
 			stderr: handleOutput(parsed.options, result.stderr),
+			all: handleOutput(parsed.options, result.all),
 			code: 0,
 			failed: false,
 			killed: false,
@@ -308,6 +335,8 @@ module.exports = (command, args, options) => {
 
 	handleInput(spawned, parsed.options.input);
 
+	spawned.all = makeAllStream(spawned);
+
 	// eslint-disable-next-line promise/prefer-await-to-then
 	spawned.then = (onFulfilled, onRejected) => handlePromise().then(onFulfilled, onRejected);
 	spawned.catch = onRejected => handlePromise().catch(onRejected);

package.json

@@ -40,6 +40,7 @@
 		"cross-spawn": "^6.0.0",
 		"get-stream": "^4.0.0",
 		"is-stream": "^1.1.0",
+		"merge-stream": "1.0.1",
 		"npm-run-path": "^2.0.0",
 		"p-finally": "^1.0.0",
 		"signal-exit": "^3.0.0",

readme.md

@@ -100,7 +100,7 @@ Execute a file.
 
 Think of this as a mix of `child_process.execFile` and `child_process.spawn`.
 
-Returns a [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout` and `stderr` properties.
+Returns a [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout`, `stderr` and `all` (interleaved `stdout` and `stderr` stream) properties.
 
 ### execa.stdout(file, [arguments], [options])
 
@@ -120,9 +120,9 @@ The `child_process` instance is enhanced to also be promise for a result object
 
 ### execa.sync(file, [arguments], [options])
 
-Execute a file synchronously.
+Execute a file synchronously. 
 
-Returns the same result object as [`child_process.spawnSync`](https://nodejs.org/api/child_process.html#child_process_child_process_spawnsync_command_args_options).
+Returns the same result object as [`child_process.spawnSync`](https://nodejs.org/api/child_process.html#child_process_child_process_spawnsync_command_args_options). It's not possible to obtain a true interleaved `all` stream as `execa` does, because `child_process.spawnSync` does not expose `stdout` and `stderr` until termination.
 
 This method throws an `Error` if the command fails.
 

test.js

@@ -46,6 +46,14 @@ test('execa.stderr()', async t => {
 	t.is(stderr, 'foo');
 });
 
+test.serial('result.all shows both `stdout` and `stderr` intermixed', async t => {
+	const result = await execa('noop-132');
+	// Due to the async nature of process.stdout/stderr on POSIX, this test
+	// is very unpredictable, although it should interleave the streams
+	// https://nodejs.org/api/process.html#process_a_note_on_process_i_os
+	t.is(result.all, '132');
+});
+
 test('stdout/stderr available on errors', async t => {
 	const err = await t.throwsAsync(execa('exit', ['2']), {message: getExitRegExp('2')});
 	t.is(typeof err.stdout, 'string');
@@ -234,7 +242,8 @@ test('do not buffer stdout when `buffer` set to `false`', async t => {
 	const promise = execa('max-buffer', ['stdout', '10'], {buffer: false});
 	const [result, stdout] = await Promise.all([
 		promise,
-		getStream(promise.stdout)
+		getStream(promise.stdout),
+		getStream(promise.all)
 	]);
 
 	t.is(result.stdout, undefined);
@@ -245,7 +254,8 @@ test('do not buffer stderr when `buffer` set to `false`', async t => {
 	const promise = execa('max-buffer', ['stderr', '10'], {buffer: false});
 	const [result, stderr] = await Promise.all([
 		promise,
-		getStream(promise.stderr)
+		getStream(promise.stderr),
+		getStream(promise.all)
 	]);
 
 	t.is(result.stderr, undefined);