bool: implicitly accept --no-bool when --bool is specified

Author: ethomson

adopt.c

@@ -32,18 +32,32 @@
 	 (x)->type == ADOPT_TYPE_VALUE)
 
 INLINE(const adopt_spec *) spec_byname(
-	adopt_parser *parser, const char *name, size_t namelen)
+	adopt_parser *parser,
+	const char *name,
+	size_t namelen,
+	int *is_converse)
 {
 	const adopt_spec *spec;
 
+	*is_converse = 0;
+
 	for (spec = parser->specs; spec->type; ++spec) {
 		if (spec->type == ADOPT_TYPE_LITERAL && namelen == 0)
 			return spec;
 
+		/* Handle "no-" prefix for boolean types */
+		if (spec->type == ADOPT_TYPE_BOOL &&
+		    strlen(spec->name) + 3 == namelen &&
+		    strncmp(name, "no-", 3) == 0 &&
+		    strncmp(name + 3, spec->name, namelen) == 0) {
+			*is_converse = 1;
+			return spec;
+		}
+
 		if (spec_is_named_type(spec) &&
-			spec->name &&
-			strlen(spec->name) == namelen &&
-			strncmp(name, spec->name, namelen) == 0)
+		    spec->name &&
+		    strlen(spec->name) == namelen &&
+		    strncmp(name, spec->name, namelen) == 0)
 			return spec;
 	}
 
@@ -114,13 +128,14 @@ static adopt_status_t parse_long(adopt_opt *opt, adopt_parser *parser)
 {
 	const adopt_spec *spec;
 	char *arg = parser->args[parser->idx++], *name = arg + 2, *eql;
+	int converse = 0;
 	size_t namelen;
 
 	namelen = (eql = strrchr(arg, '=')) ? (size_t)(eql - name) : strlen(name);
 
 	opt->arg = arg;
 
-	if ((spec = spec_byname(parser, name, namelen)) == NULL) {
+	if ((spec = spec_byname(parser, name, namelen, &converse)) == NULL) {
 		opt->spec = NULL;
 		opt->status = ADOPT_STATUS_UNKNOWN_OPTION;
 		goto done;
@@ -132,14 +147,14 @@ static adopt_status_t parse_long(adopt_opt *opt, adopt_parser *parser)
 	if (spec->type == ADOPT_TYPE_LITERAL)
 		parser->in_literal = 1;
 
-	if (spec->type == ADOPT_TYPE_BOOL && spec->value)
-		*((int *)spec->value) = 1;
+	else if (spec->type == ADOPT_TYPE_BOOL && spec->value)
+		*((int *)spec->value) = !converse;
 
-	if (spec->type == ADOPT_TYPE_SWITCH && spec->value)
+	else if (spec->type == ADOPT_TYPE_SWITCH && spec->value)
 		*((int *)spec->value) = spec->switch_value;
 
 	/* Parse values as "--foo=bar" or "--foo bar" */
-	if (spec->type == ADOPT_TYPE_VALUE) {
+	else if (spec->type == ADOPT_TYPE_VALUE) {
 		if (eql && *(eql+1))
 			opt->value = eql + 1;
 		else if ((parser->idx + 1) <= parser->args_len)

adopt.h

@@ -20,8 +20,11 @@ typedef enum {
 
 	/**
 	 * An argument that, when specified, sets a given value to true.
-	 * This is useful for arguments like "--debug".  The `value` pointer
-	 * in the returned option will be set to `1` when this is set.
+	 * This is useful for arguments like "--debug".  A converse
+	 * argument (beginning with "no-") is implicitly specified; for
+	 * example "--no-debug".  The `value` pointer in the returned
+	 * option will be set to `1` when this is specified, and set to
+	 * `0` when the converse "no-" argument is specified.
 	 */
 	ADOPT_TYPE_BOOL,
 

tests/adopt.c

@@ -131,6 +131,73 @@ void test_adopt__returns_unknown_option(void)
 	cl_assert_equal_i(ADOPT_STATUS_UNKNOWN_OPTION, status);
 }
 
+void test_adopt__bool(void)
+{
+	int foo = 0, bar = 0;
+
+	adopt_spec specs[] = {
+		{ ADOPT_TYPE_BOOL, "foo", 0, &foo, 0 },
+		{ ADOPT_TYPE_BOOL, "bar", 0, &bar, 0 },
+		{ 0 }
+	};
+
+	char *args[] = { "--foo", "-b" };
+	adopt_expected expected[] = {
+		{ &specs[0], NULL },
+		{ NULL, "-b" },
+	};
+
+	/* Parse an arg list with only bare arguments */
+	test_parse(specs, args, 2, expected, 2);
+	cl_assert_equal_i(1, foo);
+	cl_assert_equal_i(0, bar);
+}
+
+void test_adopt__bool_converse(void)
+{
+	int foo = 1, bar = 0;
+
+	adopt_spec specs[] = {
+		{ ADOPT_TYPE_BOOL, "foo", 0, &foo, 0 },
+		{ ADOPT_TYPE_BOOL, "bar", 0, &bar, 0 },
+		{ 0 }
+	};
+
+	char *args[] = { "--no-foo", "--bar" };
+	adopt_expected expected[] = {
+		{ &specs[0], NULL },
+		{ &specs[1], NULL },
+	};
+
+	/* Parse an arg list with only bare arguments */
+	test_parse(specs, args, 2, expected, 2);
+	cl_assert_equal_i(0, foo);
+	cl_assert_equal_i(1, bar);
+}
+
+void test_adopt__bool_converse_overrides(void)
+{
+	int foo = 0, bar = 0;
+
+	adopt_spec specs[] = {
+		{ ADOPT_TYPE_BOOL, "foo", 0, &foo, 0 },
+		{ ADOPT_TYPE_BOOL, "bar", 0, &bar, 0 },
+		{ 0 }
+	};
+
+	char *args[] = { "--foo", "--bar", "--no-foo" };
+	adopt_expected expected[] = {
+		{ &specs[0], NULL },
+		{ &specs[1], NULL },
+		{ &specs[0], NULL },
+	};
+
+	/* Parse an arg list with only bare arguments */
+	test_parse(specs, args, 3, expected, 3);
+	cl_assert_equal_i(0, foo);
+	cl_assert_equal_i(1, bar);
+}
+
 void test_adopt__long_switches1(void)
 {
 	int foo = 0, bar = 0;