Add .node() method

index.js

@@ -427,3 +427,15 @@ module.exports.sync = (command, args, options) => {
 };
 
 module.exports.shellSync = (command, options) => handleShell(execa.sync, command, options);
+
+module.exports.fork = (filePath, args, options) =>{
+	const absolutePath =  path.resolve(filePath);
+
+	return execa(absolutePath, args, {
+		...options,
+		stdio: stdio.fork(options),
+		execPath: absolutePath,
+		execArgv: options.execArgv || process.execArgv,
+		shell: false,
+	});
+};

lib/stdio.js

@@ -3,7 +3,7 @@ const alias = ['stdin', 'stdout', 'stderr'];
 
 const hasAlias = opts => alias.some(x => Boolean(opts[x]));
 
-module.exports = opts => {
+const stdio = opts => {
 	if (!opts) {
 		return;
 	}
@@ -39,3 +39,17 @@ module.exports = opts => {
 
 	return result;
 };
+
+module.exports = stdio;
+
+module.exports.fork = opts => {
+	let stdioOption = options.silent ? stdio(opts || {}) : 'pipe';
+	if (typeof stdioOption === "string") {
+		stdioOption = [...new Array(3)].fill(stdioOption);
+	}
+	if (!stdioOption.includes('ipc')) {
+		stdioOption.push('ipc');
+	}
+
+	return stdioOption;
+};

test.js

@@ -640,3 +640,9 @@ test('calling cancel method on a process which has been killed does not make err
 	const error = await t.throwsAsync(subprocess);
 	t.false(error.isCanceled);
 });
+
+test.only('fork', async t => {
+	const result = await execa.fork('./fixtures/simple-log.js');
+
+	t.is(result.stdout, 'ok');
+});

test/stdio.js

@@ -4,47 +4,69 @@ import stdio from '../lib/stdio';
 
 util.inspect.styles.name = 'magenta';
 
-function macro(t, input, expected) {
-	if (expected instanceof Error) {
-		t.throws(() => stdio(input), expected.message);
-		return;
-	}
-
-	const result = stdio(input);
-
-	if (typeof expected === 'object' && expected !== null) {
-		t.deepEqual(result, expected);
-	} else {
-		t.is(result, expected);
-	}
+function createMacro(func) {
+	const macro = (t, input, expected) => {
+		if (expected instanceof Error) {
+			t.throws(() => stdio(input), expected.message);
+			return;
+		}
+
+		const result = func(input);
+
+		if (typeof expected === 'object' && expected !== null) {
+			t.deepEqual(result, expected);
+		} else {
+			t.is(result, expected);
+		}
+	};
+
+	macro.title = (providedTitle, input) => `${func.name} ${(providedTitle || util.inspect(input, {colors: true}))}`;
+
+	return macro;
 }
 
-macro.title = (providedTitle, input) => providedTitle || util.inspect(input, {colors: true});
-
-test(macro, undefined, undefined);
-test(macro, null, undefined);
-
-test(macro, {stdio: 'inherit'}, 'inherit');
-test(macro, {stdio: 'pipe'}, 'pipe');
-test(macro, {stdio: 'ignore'}, 'ignore');
-test(macro, {stdio: [0, 1, 2]}, [0, 1, 2]);
-
-test(macro, {}, [undefined, undefined, undefined]);
-test(macro, {stdio: []}, [undefined, undefined, undefined]);
-test(macro, {stdin: 'pipe'}, ['pipe', undefined, undefined]);
-test(macro, {stdout: 'ignore'}, [undefined, 'ignore', undefined]);
-test(macro, {stderr: 'inherit'}, [undefined, undefined, 'inherit']);
-test(macro, {stdin: 'pipe', stdout: 'ignore', stderr: 'inherit'}, ['pipe', 'ignore', 'inherit']);
-test(macro, {stdin: 'pipe', stdout: 'ignore'}, ['pipe', 'ignore', undefined]);
-test(macro, {stdin: 'pipe', stderr: 'inherit'}, ['pipe', undefined, 'inherit']);
-test(macro, {stdout: 'ignore', stderr: 'inherit'}, [undefined, 'ignore', 'inherit']);
-test(macro, {stdin: 0, stdout: 1, stderr: 2}, [0, 1, 2]);
-test(macro, {stdin: 0, stdout: 1}, [0, 1, undefined]);
-test(macro, {stdin: 0, stderr: 2}, [0, undefined, 2]);
-test(macro, {stdout: 1, stderr: 2}, [undefined, 1, 2]);
-
-test(macro, {stdio: {foo: 'bar'}}, new TypeError('Expected `stdio` to be of type `string` or `Array`, got `object`'));
-
-test(macro, {stdin: 'inherit', stdio: 'pipe'}, new Error('It\'s not possible to provide `stdio` in combination with one of `stdin`, `stdout`, `stderr`'));
-test(macro, {stdin: 'inherit', stdio: ['pipe']}, new Error('It\'s not possible to provide `stdio` in combination with one of `stdin`, `stdout`, `stderr`'));
-test(macro, {stdin: 'inherit', stdio: [undefined, 'pipe']}, new Error('It\'s not possible to provide `stdio` in combination with one of `stdin`, `stdout`, `stderr`'));
+const stdioMacro = createMacro(stdio);
+
+test(stdioMacro, undefined, undefined);
+test(stdioMacro, null, undefined);
+
+test(stdioMacro, {stdio: 'inherit'}, 'inherit');
+test(stdioMacro, {stdio: 'pipe'}, 'pipe');
+test(stdioMacro, {stdio: 'ignore'}, 'ignore');
+test(stdioMacro, {stdio: [0, 1, 2]}, [0, 1, 2]);
+
+test(stdioMacro, {}, [undefined, undefined, undefined]);
+test(stdioMacro, {stdio: []}, [undefined, undefined, undefined]);
+test(stdioMacro, {stdin: 'pipe'}, ['pipe', undefined, undefined]);
+test(stdioMacro, {stdout: 'ignore'}, [undefined, 'ignore', undefined]);
+test(stdioMacro, {stderr: 'inherit'}, [undefined, undefined, 'inherit']);
+test(stdioMacro, {stdin: 'pipe', stdout: 'ignore', stderr: 'inherit'}, ['pipe', 'ignore', 'inherit']);
+test(stdioMacro, {stdin: 'pipe', stdout: 'ignore'}, ['pipe', 'ignore', undefined]);
+test(stdioMacro, {stdin: 'pipe', stderr: 'inherit'}, ['pipe', undefined, 'inherit']);
+test(stdioMacro, {stdout: 'ignore', stderr: 'inherit'}, [undefined, 'ignore', 'inherit']);
+test(stdioMacro, {stdin: 0, stdout: 1, stderr: 2}, [0, 1, 2]);
+test(stdioMacro, {stdin: 0, stdout: 1}, [0, 1, undefined]);
+test(stdioMacro, {stdin: 0, stderr: 2}, [0, undefined, 2]);
+test(stdioMacro, {stdout: 1, stderr: 2}, [undefined, 1, 2]);
+
+test(stdioMacro, {stdio: {foo: 'bar'}}, new TypeError('Expected `stdio` to be of type `string` or `Array`, got `object`'));
+
+test(stdioMacro, {stdin: 'inherit', stdio: 'pipe'}, new Error('It\'s not possible to provide `stdio` in combination with one of `stdin`, `stdout`, `stderr`'));
+test(stdioMacro, {stdin: 'inherit', stdio: ['pipe']}, new Error('It\'s not possible to provide `stdio` in combination with one of `stdin`, `stdout`, `stderr`'));
+test(stdioMacro, {stdin: 'inherit', stdio: [undefined, 'pipe']}, new Error('It\'s not possible to provide `stdio` in combination with one of `stdin`, `stdout`, `stderr`'));
+
+const forkMacro = createMacro(stdio.fork);
+
+test(forkMacro, undefined, ['inherit', 'inherit', 'inherit', 'ipc']);
+test(forkMacro, {stdio: 'ignore'}, ['ignore', 'ignore', 'ignore', 'ipc']);
+test(forkMacro, {stdio: [0, 1, 2]}, [0, 1, 2, 'ipc']);
+test(forkMacro, {stdio: [0, 1, 2, 3]}, [0, 1, 2, 3, 'ipc']);
+test(forkMacro, {stdio: [0, 1, 2, 'ipc']}, [0, 1, 2, 'ipc']);
+
+test(forkMacro, {stdout: 'ignore'}, ['inherit', 'ignore', 'inherit', 'ipc']);
+test(forkMacro, {stdout: 'ignore', stderr: 'ignore'}, ['inherit', 'ignore', 'ignore', 'ipc']);
+
+test(forkMacro, {silent: true}, ['pipe', 'pipe', 'pipe', 'ipc']);
+test(forkMacro, {silent: true, stdio: 'ignore'}, ['ignore', 'ignore', 'ignore', 'ipc']);
+test(forkMacro, {silent: true, stdio: [0, 1, 2]}, [0, 1, 2, 'ipc']);
+test(forkMacro, {silent: true, stdout: 'ignore'}, ['pipe', 'ignore', 'pipe', 'ipc']);