Add isRequired flag option

index.d.ts

@@ -2,11 +2,13 @@ import {PackageJson} from 'type-fest';
 
 declare namespace meow {
 	type FlagType = 'string' | 'boolean' | 'number';
+	type IsRequiredPredicate = (flags: AnyFlags, input: string[]) => boolean;
 
 	interface Flag<Type extends FlagType, Default> {
 		readonly type?: Type;
 		readonly alias?: string;
 		readonly default?: Default;
+		readonly isRequired?: boolean | IsRequiredPredicate
 	}
 
 	type StringFlag = Flag<'string', string>;
@@ -24,6 +26,11 @@ declare namespace meow {
 		- `type`: Type of value. (Possible values: `string` `boolean` `number`)
 		- `alias`: Usually used to define a short flag alias.
 		- `default`: Default value when the flag is not specified.
+		- `isRequired`: Boolean or Function that specifies if this flag is required.
+			Two arguments are passed to the function.
+			The first arguments is the flags object, it contains the flags converted to camelCase excluding aliases.
+			The second arugment is the input string array, it contains the non-flag arguments.
+			The function should return a Boolean, true if the flag is requried, otherwise false.
 
 		@example
 		```
@@ -32,6 +39,11 @@ declare namespace meow {
 				type: 'string',
 				alias: 'u',
 				default: 'rainbow'
+				isRequired: (flags, input) => {
+					if (flags.otherFlag) {
+						return true;
+					}
+				}
 			}
 		}
 		```

index.js

@@ -14,6 +14,37 @@ const normalizePackageData = require('normalize-package-data');
 delete require.cache[__filename];
 const parentDir = path.dirname(module.parent.filename);
 
+const isFlagMissing = (flagName, definedFlags, receivedFlags, input) => {
+	const flag = definedFlags[flagName];
+	let isFlagRequired = true;
+
+	if (typeof flag.isRequired === 'function') {
+		isFlagRequired = flag.isRequired(receivedFlags, input);
+	}
+
+	return typeof receivedFlags[flagName] === 'undefined' && isFlagRequired;
+};
+
+const getMissingRequiredFlags = (flags, receivedFlags, input) => {
+	const missingRequiredFlags = [];
+	if (typeof flags !== 'undefined') {
+		for (const flagName of Object.keys(flags)) {
+			if (flags[flagName].isRequired && isFlagMissing(flagName, flags, receivedFlags, input)) {
+				missingRequiredFlags.push({key: flagName, ...flags[flagName]});
+			}
+		}
+	}
+
+	return missingRequiredFlags;
+};
+
+const reportMissingRequiredFlags = missingRequiredFlags => {
+	console.error(`Missing required flag${missingRequiredFlags.length > 1 ? 's' : ''}`);
+	for (const flag of missingRequiredFlags) {
+		console.error(`\t--${flag.key}${flag.alias ? `, -${flag.alias}` : ''}`);
+	}
+};
+
 const meow = (helpText, options) => {
 	if (typeof helpText !== 'string') {
 		options = helpText;
@@ -118,6 +149,15 @@ const meow = (helpText, options) => {
 		}
 	}
 
+	// Get a list of missing flags that are required
+	const missingRequiredFlags = getMissingRequiredFlags(options.flags, flags, input);
+
+	// Print error message for missing flags that are required
+	if (missingRequiredFlags.length > 0) {
+		reportMissingRequiredFlags(missingRequiredFlags);
+		process.exit(2);
+	}
+
 	return {
 		input,
 		flags,

package.json

@@ -63,5 +63,10 @@
 		"rules": {
 			"unicorn/no-process-exit": "off"
 		}
+	},
+	"ava": {
+		"files": [
+			"test/*"
+		]
 	}
 }

readme.md

@@ -97,6 +97,11 @@ The key is the flag name and the value is an object with any of:
 - `type`: Type of value. (Possible values: `string` `boolean` `number`)
 - `alias`: Usually used to define a short flag alias.
 - `default`: Default value when the flag is not specified.
+- `isRequired`: Boolean or Function that specifies if this flag is required.
+	Two arguments are passed to the function.
+	The first arguments is the **flags** object, it contains the flags converted to camelCase excluding aliases.
+	The second arugment is the **input** string array, it contains the non-flag arguments.
+	The function should return a Boolean, true if the flag is requried, otherwise false.
 
 Example:
 
@@ -106,6 +111,11 @@ flags: {
 		type: 'string',
 		alias: 'u',
 		default: 'rainbow'
+		isRequired: (flags, input) => {
+			if (flags.otherFlag) {
+				return true;
+			}
+		}
 	}
 }
 ```

test/fixtures/fixture-required-function.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+'use strict';
+const meow = require('../..');
+
+const cli = meow({
+	description: 'Custom description',
+	help: `
+		Usage
+		  foo <input>
+  `,
+	flags: {
+		trigger: {
+			type: 'boolean',
+			alias: 't'
+		},
+		withTrigger: {
+			type: 'string',
+			isRequired: (flags, _) => {
+				return flags.trigger;
+			}
+		}
+	}
+});
+console.log(`${cli.flags.trigger},${cli.flags.withTrigger}`);

test/fixtures/fixture-required.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+const meow = require('../..');
+
+const cli = meow({
+	description: 'Custom description',
+	help: `
+		Usage
+		  foo <input>
+  `,
+	flags: {
+		test: {
+			type: 'string',
+			alias: 't',
+			isRequired: true
+		},
+		number: {
+			type: 'number',
+			isRequired: true
+		},
+		notRequired: {
+			type: 'string'
+		}
+	}
+});
+console.log(`${cli.flags.test},${cli.flags.number}`);

fixture.js → test/fixtures/fixture.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 'use strict';
-const meow = require('.');
+const meow = require('../..');
 
 const cli = meow({
 	description: 'Custom description',

test/test-is-required-flag.js

@@ -0,0 +1,72 @@
+import test from 'ava';
+import execa from 'execa';
+const path = require('path');
+
+const fixtureRequiredPath = path.join(__dirname, 'fixtures', 'fixture-required.js');
+const fixtureRequiredFunctionPath = path.join(__dirname, 'fixtures', 'fixture-required-function.js');
+
+test('spawn cli and test not specifying required flags', async t => {
+	try {
+		await execa(fixtureRequiredPath, []);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.regex(stderr, /--test, -t/);
+		t.regex(stderr, /--number/);
+		t.notRegex(stderr, /--notRequired/);
+	}
+});
+
+test('spawn cli and test specifying all required flags', async t => {
+	const {stdout} = await execa(fixtureRequiredPath, [
+		'-t',
+		'test',
+		'--number',
+		'6'
+	]);
+	t.is(stdout, 'test,6');
+});
+
+test('spawn cli and test specifying required string flag with an empty string as value', async t => {
+	try {
+		await execa(fixtureRequiredPath, ['--test', '']);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.notRegex(stderr, /--test, -t/);
+	}
+});
+
+test('spawn cli and test specifying required number flag without a number', async t => {
+	try {
+		await execa(fixtureRequiredPath, ['--number']);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.regex(stderr, /--number/);
+	}
+});
+
+test('spawn cli and test setting isRequired as a function and not specifying any flags', async t => {
+	const {stdout} = await execa(fixtureRequiredFunctionPath, []);
+	t.is(stdout, 'false,undefined');
+});
+
+test('spawn cli and test setting isRequired as a function and specifying only the flag that activates the isRequired condition for the other flag', async t => {
+	try {
+		await execa(fixtureRequiredFunctionPath, ['--trigger']);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.regex(stderr, /--withTrigger/);
+	}
+});
+
+test('spawn cli and test setting isRequired as a function and specifying both the flags', async t => {
+	const {stdout} = await execa(fixtureRequiredFunctionPath, ['--trigger', '--withTrigger', 'specified']);
+	t.is(stdout, 'true,specified');
+});

test.js → test/test.js

@@ -1,8 +1,11 @@
 import test from 'ava';
 import indentString from 'indent-string';
 import execa from 'execa';
-import pkg from './package.json';
-import meow from '.';
+import pkg from '../package.json';
+import meow from '..';
+const path = require('path');
+
+const fixturePath = path.join(__dirname, 'fixtures', 'fixture.js');
 
 test('return object', t => {
 	const cli = meow({
@@ -36,47 +39,47 @@ test('support help shortcut', t => {
 });
 
 test('spawn cli and show version', async t => {
-	const {stdout} = await execa('./fixture.js', ['--version']);
+	const {stdout} = await execa(fixturePath, ['--version']);
 	t.is(stdout, pkg.version);
 });
 
 test('spawn cli and disabled autoVersion and autoHelp', async t => {
-	const {stdout} = await execa('./fixture.js', ['--version', '--help']);
+	const {stdout} = await execa(fixturePath, ['--version', '--help']);
 	t.is(stdout, 'version\nhelp\nmeow\ncamelCaseOption');
 });
 
 test('spawn cli and disabled autoVersion', async t => {
-	const {stdout} = await execa('./fixture.js', ['--version', '--no-auto-version']);
+	const {stdout} = await execa(fixturePath, ['--version', '--no-auto-version']);
 	t.is(stdout, 'version\nautoVersion\nmeow\ncamelCaseOption');
 });
 
 test('spawn cli and not show version', async t => {
-	const {stdout} = await execa('./fixture.js', ['--version=beta']);
+	const {stdout} = await execa(fixturePath, ['--version=beta']);
 	t.is(stdout, 'version\nmeow\ncamelCaseOption');
 });
 
 test('spawn cli and show help screen', async t => {
-	const {stdout} = await execa('./fixture.js', ['--help']);
+	const {stdout} = await execa(fixturePath, ['--help']);
 	t.is(stdout, indentString('\nCustom description\n\nUsage\n  foo <input>\n\n', 2));
 });
 
 test('spawn cli and disabled autoHelp', async t => {
-	const {stdout} = await execa('./fixture.js', ['--help', '--no-auto-help']);
+	const {stdout} = await execa(fixturePath, ['--help', '--no-auto-help']);
 	t.is(stdout, 'help\nautoHelp\nmeow\ncamelCaseOption');
 });
 
 test('spawn cli and not show help', async t => {
-	const {stdout} = await execa('./fixture.js', ['--help=all']);
+	const {stdout} = await execa(fixturePath, ['--help=all']);
 	t.is(stdout, 'help\nmeow\ncamelCaseOption');
 });
 
 test('spawn cli and test input', async t => {
-	const {stdout} = await execa('./fixture.js', ['-u', 'cat']);
+	const {stdout} = await execa(fixturePath, ['-u', 'cat']);
 	t.is(stdout, 'unicorn\nmeow\ncamelCaseOption');
 });
 
 test('spawn cli and test input flag', async t => {
-	const {stdout} = await execa('./fixture.js', ['--camel-case-option', 'bar']);
+	const {stdout} = await execa(fixturePath, ['--camel-case-option', 'bar']);
 	t.is(stdout, 'bar');
 });