Skip to contentSkip to conversation

commit-tree: utilize parse-options api

PATCH Superseded Brandon Richardson 3 participants 4 messages Mar 5, 2019 – Mar 7, 2019 Documentation

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

PATCH v4 1/1 commit-tree: utilize parse-options api

Rather than parse options manually, which is both difficult to read and error prone, parse options supplied to commit-tree using the parse-options api.

It was discovered that the --no-gpg-sign option was documented but not implemented in commit 70ddbd7767 (commit-tree: add missing --gpg-sign flag, 2019-01-19), and the existing implementation would attempt to translate the option as a tree oid. It was also suggested earlier in commit 55ca3f99ae (commit-tree: add and document --no-gpg-sign, 2013-12-13) that commit-tree should be migrated to utilize the parse-options api, which could help prevent mistakes like this in the future. Hence this change.

Also update the documentation to better describe that mixing -m and -F options will correctly compose commit log messages in the order in which the options are given.

In the process, mark various strings for translation.

---

Notes:
GitHub Pull Request: https://github.com/brandon1024/git/pull/4
Travis CI Build: https://travis-ci.com/brandon1024/git/builds/103055317

 Documentation/git-commit-tree.txt |   8 +-
 builtin/commit-tree.c             | 158 ++++++++++++++++--------------
 parse-options.h                   |  11 +++
 3 files changed, 103 insertions(+), 74 deletions(-)
Documentation/git-commit-tree.txt +6 -2
index 002dae625e..f4e20b62a0 100644
@@ -23,6 +23,9 @@ Creates a new commit object based on the provided tree object and
 emits the new commit object id on stdout. The log message is read
 from the standard input, unless `-m` or `-F` options are given.
 
+When mixing `-m` and `-F` options, the commit log message will be
+composed in the order in which the options are given.
+
 A commit object may have any number of parents. With exactly one
 parent, it is an ordinary commit. Having more than one parent makes
 the commit a merge between several lines of history. Initial (root)
@@ -41,7 +44,7 @@ state was.
 OPTIONS
 -------
 <tree>::
-	An existing tree object
+	An existing tree object.
 
 -p <parent>::
 	Each `-p` indicates the id of a parent commit object.
@@ -52,7 +55,8 @@ OPTIONS
 
 -F <file>::
 	Read the commit log message from the given file. Use `-` to read
-	from the standard input.
+	from the standard input. This can be given more than once and the
+	content of each file becomes its own paragraph.
 
 -S[<keyid>]::
 --gpg-sign[=<keyid>]::
builtin/commit-tree.c +86 -72

192 lines not on this page · raw message

parse-options.h +11 -0
index 14fe32428e..3a442eee26 100644
@@ -202,6 +202,17 @@ const char *optname(const struct option *opt, int flags);
 		BUG("option callback does not expect an argument"); \
 } while (0)
 
+/*
+ * Similar to the assertions above, but checks that "arg" is always non-NULL.
+ * This assertion also implies BUG_ON_OPT_NEG(), letting you declare both
+ * assertions in a single line.
+ */
+#define BUG_ON_OPT_NEG_NOARG(unset, arg) do { \
+	BUG_ON_OPT_NEG(unset); \
+	if(!(arg)) \
+		BUG("option callback expects an argument"); \
+} while(0)
+
 /*----- incremental advanced APIs -----*/
 
 enum {
Signature · 1 line
2.21.0
#1 lore raw

Documentation/git-commit-tree.txt Creates a new commit object based on the provided tree object and · line 27

Quoted 6 lines · Brandon Richardson
Documentation/git-commit-tree.txt +2 -0
@@ -23,6 +23,9 @@ Creates a new commit object based on the provided tree object and
 emits the new commit object id on stdout. The log message is read
 from the standard input, unless `-m` or `-F` options are given.
 
+When mixing `-m` and `-F` options, the commit log message will be
+composed in the order in which the options are given.

It may be just me, but this new paragraph made me think that we can give at most one -m and one -F option at the same time in any order, and multiple -m or -F options are not supported. That, obviously, is not the impression we want to give to the readers.

Even when you are not mixing -m and -F, but using -m more than once, the log message will be composed in the order in which options are given. So probably the word "mixing" is the primary culprit of making the sentence easier to be misunderstood.

When using more than one -m or -F options, ...

perhaps.

Documentation/git-commit-tree.txt state was. · line 47

Quoted 6 lines
Documentation/git-commit-tree.txt +1 -1
@@ -41,7 +44,7 @@ state was.
 OPTIONS
 -------
 <tree>::
-	An existing tree object
+	An existing tree object.

Good.

Documentation/git-commit-tree.txt OPTIONS · line 59

Quoted 7 lines
Documentation/git-commit-tree.txt +2 -1
@@ -52,7 +55,8 @@ OPTIONS
 
 -F <file>::
 	Read the commit log message from the given file. Use `-` to read
-	from the standard input.
+	from the standard input. This can be given more than once and the
+	content of each file becomes its own paragraph.

OK, this matches what -m says about giving it multiple times.

builtin/commit-tree.c line 21

Quoted 6 lines
builtin/commit-tree.c +5 -1
-static const char commit_tree_usage[] = "git commit-tree [(-p <sha1>)...] [-S[<keyid>]] [-m <message>] [-F <file>] <sha1>";
+static const char * const commit_tree_usage[] = {
+	N_("git commit-tree [(-p <parent>)...] [-S[<keyid>]] [(-m <message>)...] "
+		"[(-F <file>)...] <tree>"),
+	NULL
+};

Replacing a few placeholder tokens with more meaningful names---very good attention to the detail.

Quoted 4 lines
builtin/commit-tree.c +4 -0
+static int parse_parent_arg_callback(const struct option *opt,
+		const char *arg, int unset)
+{
+	struct object_id oid;

builtin/commit-tree.c static int commit_tree_config(const char *var, const char *value, void *cb) · line 60

Quoted 10 lines
builtin/commit-tree.c +10 -0
+	struct commit_list **parents = opt->value;
+
+	BUG_ON_OPT_NEG_NOARG(unset, arg);
+
+	if (get_oid_commit(arg, &oid))
+		die(_("not a valid object name %s"), arg);
+
+	assert_oid_type(&oid, OBJ_COMMIT);
+	new_parent(lookup_commit(the_repository, &oid), parents);
+	return 0;

OK, this looks like a quite faithful conversion. We do not allow tags that point at commit, for example. Good.

Quoted 6 lines
builtin/commit-tree.c +6 -0
+}
+
+static int parse_message_arg_callback(const struct option *opt,
+		const char *arg, int unset)
+{
+	struct strbuf *buf = opt->value;

builtin/commit-tree.c static int commit_tree_config(const char *var, const char *value, void *cb) · line 76

Quoted 10 lines
builtin/commit-tree.c +10 -0
+
+	BUG_ON_OPT_NEG_NOARG(unset, arg);
+
+	if (buf->len)
+		strbuf_addch(buf, '\n');
+	strbuf_addstr(buf, arg);
+	strbuf_complete_line(buf);
+
+	return 0;
+}

Likewise. We make ourselves a new paragraph (if there is already some message), add the message and complete the line. Good.

Quoted 14 lines
builtin/commit-tree.c +14 -0
+static int parse_file_arg_callback(const struct option *opt,
+		const char *arg, int unset)
+{
+	int fd;
+	struct strbuf *buf = opt->value;
+
+	BUG_ON_OPT_NEG_NOARG(unset, arg);
+
+	if (buf->len)
+		strbuf_addch(buf, '\n');
+	if (!strcmp(arg, "-"))
+		fd = 0;
+	else {
+		fd = open(arg, O_RDONLY);

builtin/commit-tree.c static int commit_tree_config(const char *var, const char *value, void *cb) · line 101

Quoted 10 lines
builtin/commit-tree.c +10 -0
+		if (fd < 0)
+			die_errno(_("git commit-tree: failed to open '%s'"), arg);
+	}
+	if (strbuf_read(buf, fd, 0) < 0)
+		die_errno(_("git commit-tree: failed to read '%s'"), arg);
+	if (fd && close(fd))
+		die_errno(_("git commit-tree: failed to close '%s'"), arg);
+
+	return 0;
+}

Again, likewise. And it is far easier to see and read what is going on, compared to the original that has 2 extra levels of indentation.

Quoted 2 lines

int cmd_commit_tree(int argc, const char **argv, const char *prefix) {

The change to this main function looks quite straight-forward. I am kind of surprised that a very low hanging fruit like this had survived without getting hit by parseopt a lot earlier ;-)

#2 lore raw
Quoted 9 lines · Junio C Hamano

Documentation/git-commit-tree.txt Creates a new commit object based on the provided tree object and · line 27

Quoted 3 lines
Documentation/git-commit-tree.txt +2 -0
+When mixing `-m` and `-F` options, the commit log message will be
+composed in the order in which the options are given.

It may be just me, but this new paragraph made me think that we can give at most one -m and one -F option at the same time in any order, and multiple -m or -F options are not supported. That, obviously, is not the impression we want to give to the readers.

Quoted 8 lines

Even when you are not mixing -m and -F, but using -m more than once, the log message will be composed in the order in which options are given. So probably the word "mixing" is the primary culprit of making the sentence easier to be misunderstood.

When using more than one -m or -F options, ...

perhaps.

Good call, 'mixing' is not the right word here. Will fix.

Quoted 3 lines

The change to this main function looks quite straight-forward. I am kind of surprised that a very low hanging fruit like this had survived without getting hit by parseopt a lot earlier ;-)

I was surprised too, commit-tree hasn't seen much love over the years. There are certainly others that could benefit from parse-options.

#3 lore raw
In reply to Junio C Hamano
Quoted 3 lines · Junio C Hamano

The change to this main function looks quite straight-forward. I am kind of surprised that a very low hanging fruit like this had survived without getting hit by parseopt a lot earlier ;-)

There are more (I guess we tag #leftovers nowadays?)

git grep 'strcmp.*\"--[a-z]' builtin/

(with some false positives)

Signature · 1 line
Duy