requirements: enforce requirements in adopt_parse

When performing a simple, complete parsing in `adopt_parse`, enforce
required arguments that are missing.  `adopt_parse` now returns
`ADOPT_STATUS_MISSING_ARGUMENT` if any argument is missing, and
`adopt_status_fprint` has learned how to print information about missing
arguments.

Author: ethomson

adopt.c

@@ -247,30 +247,117 @@ adopt_status_t adopt_parser_next(adopt_opt *opt, adopt_parser *parser)
 		return parse_arg(opt, parser);
 }
 
+INLINE(int) spec_included(const adopt_spec **specs, const adopt_spec *spec)
+{
+	const adopt_spec **i;
+
+	for (i = specs; *i; ++i) {
+		if (spec == *i)
+			return 1;
+	}
+
+	return 0;
+}
+
+INLINE(int) spec_is_choice(const adopt_spec *spec)
+{
+	return ((spec + 1)->type &&
+	       ((spec + 1)->usage & ADOPT_USAGE_CHOICE));
+}
+
+static adopt_status_t validate_required(
+	adopt_opt *opt,
+	const adopt_spec specs[],
+	const adopt_spec **given_specs)
+{
+	const adopt_spec *spec, *required;
+	int given;
+
+	/*
+	 * Iterate over the possible specs to identify requirements and
+	 * ensure that those have been given on the command-line.
+	 * Note that we can have required *choices*, where one in a
+	 * list of choices must be specified.
+	 */
+	for (spec = specs, required = NULL, given = 0; spec->type; ++spec) {
+		if (!required && (spec->usage & ADOPT_USAGE_REQUIRED)) {
+			required = spec;
+			given = 0;
+		} else if (!required) {
+			continue;
+		}
+
+		if (!given)
+			given = spec_included(given_specs, spec);
+
+		/*
+		 * Validate the requirement unless we're in a required
+		 * choice.  In that case, keep the required state and
+		 * validate at the end of the choice list.
+		 */
+		if (!spec_is_choice(spec)) {
+			if (!given) {
+				opt->spec = required;
+				opt->status = ADOPT_STATUS_MISSING_ARGUMENT;
+				break;
+			}
+
+			required = NULL;
+			given = 0;
+		}
+	}
+
+	return opt->status;
+}
+
 adopt_status_t adopt_parse(
 	adopt_opt *opt,
 	const adopt_spec specs[],
 	char **args,
 	size_t args_len)
 {
 	adopt_parser parser;
+	const adopt_spec **given_specs;
+	size_t given_idx = 0;
 
 	adopt_parser_init(&parser, specs, args, args_len);
 
+	given_specs = alloca(sizeof(const adopt_spec *) * (args_len + 1));
+
 	while (adopt_parser_next(opt, &parser)) {
 		if (opt->status != ADOPT_STATUS_OK &&
-		    opt->status != ADOPT_STATUS_DONE) {
-			break;
-		}
+		    opt->status != ADOPT_STATUS_DONE)
+			return opt->status;
+
+		given_specs[given_idx++] = opt->spec;
 	}
 
-	return opt->status;
+	given_specs[given_idx] = NULL;
+
+	return validate_required(opt, specs, given_specs);
+}
+
+static int spec_name_fprint(FILE *file, const adopt_spec *spec)
+{
+	int error;
+
+	if (spec->type == ADOPT_ARG)
+		error = fprintf(file, "%s", spec->value_name);
+	else if (spec->type == ADOPT_ARGS)
+		error = fprintf(file, "%s", spec->value_name);
+	else if (spec->alias && !(spec->usage & ADOPT_USAGE_SHOW_LONG))
+		error = fprintf(file, "-%c", spec->alias);
+	else
+		error = fprintf(file, "--%s", spec->name);
+
+	return error;
 }
 
 int adopt_status_fprint(
 	FILE *file,
 	const adopt_opt *opt)
 {
+	const adopt_spec *choice;
 	int error;
 
 	switch (opt->status) {
@@ -284,12 +371,46 @@ int adopt_status_fprint(
 		error = fprintf(file, "Unknown option: %s\n", opt->arg);
 		break;
 	case ADOPT_STATUS_MISSING_VALUE:
-		if (strncmp(opt->arg, "--", 2) == 0)
-			error = fprintf(file, "Option '%s' requires a value.\n",
-				opt->spec->name);
-		else
-			error = fprintf(file, "Switch '%c' requires a value.\n",
-				opt->spec->alias);
+		if ((error = fprintf(file, "Argument '")) < 0 ||
+		    (error = spec_name_fprint(file, opt->spec)) < 0 ||
+		    (error = fprintf(file, "' requires a value.\n")) < 0)
+			;
+		break;
+	case ADOPT_STATUS_MISSING_ARGUMENT:
+		if (spec_is_choice(opt->spec)) {
+			int is_choice = 1;
+
+			if ((error = fprintf(file, "One argument of")) < 0)
+				break;
+
+			for (choice = opt->spec; is_choice; ++choice) {
+				is_choice = spec_is_choice(choice);
+
+				if (!is_choice)
+					error = fprintf(file, " or");
+				else if (choice != opt->spec)
+					error = fprintf(file, ",");
+
+				if ((error < 0) ||
+				    (error = fprintf(file, " '")) < 0 ||
+				    (error = spec_name_fprint(file, choice)) < 0 ||
+				    (error = fprintf(file, "'")) < 0)
+					break;
+
+				if (!spec_is_choice(choice))
+					break;
+			}
+
+			if ((error < 0) ||
+			    (error = fprintf(file, " is required.\n")) < 0)
+				break;
+		} else {
+			if ((error = fprintf(file, "Argument '")) < 0 ||
+			    (error = spec_name_fprint(file, opt->spec)) < 0 ||
+			    (error = fprintf(file, "' is required.\n")) < 0)
+				break;
+		}
+
 		break;
 	default:
 		error = fprintf(file, "Unknown status: %d\n", opt->status);

adopt.h

@@ -142,6 +142,9 @@ typedef enum {
 	 * was provided.
 	 */
 	ADOPT_STATUS_MISSING_VALUE = 3,
+
+	/** A required argument was not provided. */
+	ADOPT_STATUS_MISSING_ARGUMENT = 4,
 } adopt_status_t;
 
 /** An option provided on the command-line. */

examples/loop.c

@@ -21,7 +21,7 @@ adopt_spec opt_specs[] = {
 	{ ADOPT_BOOL, "verbose", 'v', &verbose, 0,
       NULL, "Turn on verbose information", 0 },
 	{ ADOPT_SWITCH, "quiet", 'q', &volume, 0,
-	  NULL, "Emit no output", 0 },
+	  NULL, "Emit no output", ADOPT_USAGE_REQUIRED },
 	{ ADOPT_SWITCH, "loud", 'l', &volume, 2,
 	  NULL, "Emit louder than usual output", ADOPT_USAGE_CHOICE },
 	{ ADOPT_VALUE, "channel", 'c', &channel, 0,

examples/parse.c

@@ -19,9 +19,9 @@ static char **other = NULL;
 
 adopt_spec opt_specs[] = {
 	{ ADOPT_BOOL, "verbose", 'v', &verbose, 0,
-      NULL, "Turn on verbose information", 0 },
+	  NULL, "Turn on verbose information", 0 },
 	{ ADOPT_SWITCH, "quiet", 'q', &volume, 0,
-	  NULL, "Emit no output", 0 },
+	  NULL, "Emit no output", ADOPT_USAGE_REQUIRED },
 	{ ADOPT_SWITCH, "loud", 'l', &volume, 2,
 	  NULL, "Emit louder than usual output", ADOPT_USAGE_CHOICE },
 	{ ADOPT_VALUE, "channel", 'c', &channel, 0,
@@ -55,18 +55,12 @@ int main(int argc, char **argv)
 	adopt_opt result;
 	size_t i;
 
-	if (adopt_parse(&result, opt_specs, argv + 1, argc - 1) < 0) {
+	if (adopt_parse(&result, opt_specs, argv + 1, argc - 1) != 0) {
 		adopt_status_fprint(stderr, &result);
 		adopt_usage_fprint(stderr, argv[0], opt_specs);
 		return 129;
 	}
 
-	if (!filename1) {
-		fprintf(stderr, "filename is required\n");
-		adopt_usage_fprint(stderr, argv[0], opt_specs);
-		return 129;
-	}
-
 	printf("verbose: %d\n", verbose);
 	printf("volume: %s\n", volume_tostr(volume));
 	printf("channel: %s\n", channel ? channel : "(null)");

tests/adopt.c

@@ -755,3 +755,73 @@ void test_adopt__parse_args_implies_literal(void)
 	cl_assert_equal_s("--bar", argz[2]);
 }
 
+void test_adopt__value_required(void)
+{
+	int foo = 0;
+	char *bar = NULL, **argz = NULL;
+	adopt_opt result;
+
+	adopt_spec specs[] = {
+		{ ADOPT_SWITCH, "foo", 'f', &foo,  'f' },
+		{ ADOPT_VALUE,  "bar",  0,  &bar,  'b' },
+		{ ADOPT_ARGS,   "argz", 0,  &argz,  0  },
+		{ 0 },
+	};
+
+	char *args[] = { "-f", "--bar" };
+
+	cl_must_pass(adopt_parse(&result, specs, args, 2));
+
+	cl_assert_equal_i(ADOPT_STATUS_MISSING_VALUE, result.status);
+}
+
+void test_adopt__required_choice_missing(void)
+{
+	int foo = 0;
+	char *bar = NULL, **argz = NULL;
+	adopt_opt result;
+
+	adopt_spec specs[] = {
+		{ ADOPT_SWITCH, "foo", 'f', &foo,  'f', NULL, NULL, ADOPT_USAGE_REQUIRED },
+		{ ADOPT_VALUE,  "bar",  0,  &bar,  'b', NULL, NULL, ADOPT_USAGE_CHOICE },
+		{ ADOPT_ARGS,   "argz", 0,  &argz,  0,  NULL, NULL, 0 },
+		{ 0 },
+	};
+
+	char *args[] = { "foo", "bar" };
+
+	cl_assert_equal_i(ADOPT_STATUS_MISSING_ARGUMENT, adopt_parse(&result, specs, args, 2));
+
+	cl_assert_equal_i(ADOPT_STATUS_MISSING_ARGUMENT, result.status);
+	cl_assert_equal_s("foo", result.spec->name);
+	cl_assert_equal_i('f', result.spec->alias);
+	cl_assert_equal_p(NULL, result.arg);
+	cl_assert_equal_p(NULL, result.value);
+	cl_assert_equal_i(2, result.args_len);
+}
+
+void test_adopt__required_choice_specified(void)
+{
+	int foo = 0;
+	char *bar = NULL, *baz = NULL, **argz = NULL;
+	adopt_opt result;
+
+	adopt_spec specs[] = {
+		{ ADOPT_SWITCH, "foo", 'f', &foo,  'f', NULL, NULL, ADOPT_USAGE_REQUIRED },
+		{ ADOPT_VALUE,  "bar",  0,  &bar,  'b', NULL, NULL, ADOPT_USAGE_CHOICE },
+		{ ADOPT_ARG,    "baz",  0,  &baz,  'z', NULL, NULL, ADOPT_USAGE_REQUIRED },
+		{ ADOPT_ARGS,   "argz", 0,  &argz,  0,  NULL, NULL, 0 },
+		{ 0 },
+	};
+
+	char *args[] = { "--bar" };
+
+	cl_assert_equal_i(ADOPT_STATUS_MISSING_ARGUMENT, adopt_parse(&result, specs, args, 2));
+
+	cl_assert_equal_i(ADOPT_STATUS_MISSING_ARGUMENT, result.status);
+	cl_assert_equal_s("baz", result.spec->name);
+	cl_assert_equal_i(0, result.spec->alias);
+	cl_assert_equal_p(NULL, result.arg);
+	cl_assert_equal_p(NULL, result.value);
+	cl_assert_equal_i(0, result.args_len);
+}