pretty: add support for "valueonly" option in %(trailers)

[thirdparty/git.git] / pretty.c

diff --git a/pretty.c b/pretty.c
index 8ca29e92815608437ccb1fb9909e78d5b4989529..fe73916adc88880dd75d2323fb36fca8fa52d4f3 100644 (file)
--- a/pretty.c
+++ b/pretty.c
@@ -1056,13 +1056,26 @@ static size_t parse_padding_placeholder(struct strbuf *sb,
        return 0;
 }
 
-static int match_placeholder_arg(const char *to_parse, const char *candidate,
-                                const char **end)
+static int match_placeholder_arg_value(const char *to_parse, const char *candidate,
+                                      const char **end, const char **valuestart,
+                                      size_t *valuelen)
 {
        const char *p;
 
        if (!(skip_prefix(to_parse, candidate, &p)))
                return 0;
+       if (valuestart) {
+               if (*p == '=') {
+                       *valuestart = p + 1;
+                       *valuelen = strcspn(*valuestart, ",)");
+                       p = *valuestart + *valuelen;
+               } else {
+                       if (*p != ',' && *p != ')')
+                               return 0;
+                       *valuestart = NULL;
+                       *valuelen = 0;
+               }
+       }
        if (*p == ',') {
                *end = p + 1;
                return 1;
@@ -1074,6 +1087,47 @@ static int match_placeholder_arg(const char *to_parse, const char *candidate,
        return 0;
 }
 
+static int match_placeholder_bool_arg(const char *to_parse, const char *candidate,
+                                     const char **end, int *val)
+{
+       const char *argval;
+       char *strval;
+       size_t arglen;
+       int v;
+
+       if (!match_placeholder_arg_value(to_parse, candidate, end, &argval, &arglen))
+               return 0;
+
+       if (!argval) {
+               *val = 1;
+               return 1;
+       }
+
+       strval = xstrndup(argval, arglen);
+       v = git_parse_maybe_bool(strval);
+       free(strval);
+
+       if (v == -1)
+               return 0;
+
+       *val = v;
+
+       return 1;
+}
+
+static int format_trailer_match_cb(const struct strbuf *key, void *ud)
+{
+       const struct string_list *list = ud;
+       const struct string_list_item *item;
+
+       for_each_string_list_item (item, list) {
+               if (key->len == (uintptr_t)item->util &&
+                   !strncasecmp(item->string, key->buf, key->len))
+                       return 1;
+       }
+       return 0;
+}
+
 static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
                                const char *placeholder,
                                void *context)
@@ -1256,6 +1310,14 @@ static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
                        if (c->signature_check.key)
                                strbuf_addstr(sb, c->signature_check.key);
                        break;
+               case 'F':
+                       if (c->signature_check.fingerprint)
+                               strbuf_addstr(sb, c->signature_check.fingerprint);
+                       break;
+               case 'P':
+                       if (c->signature_check.primary_key_fingerprint)
+                               strbuf_addstr(sb, c->signature_check.primary_key_fingerprint);
+                       break;
                default:
                        return 0;
                }
@@ -1304,24 +1366,43 @@ static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
 
        if (skip_prefix(placeholder, "(trailers", &arg)) {
                struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
+               struct string_list filter_list = STRING_LIST_INIT_NODUP;
+               size_t ret = 0;
 
                opts.no_divider = 1;
 
                if (*arg == ':') {
                        arg++;
                        for (;;) {
-                               if (match_placeholder_arg(arg, "only", &arg))
+                               const char *argval;
+                               size_t arglen;
+
+                               if (match_placeholder_arg_value(arg, "key", &arg, &argval, &arglen)) {
+                                       uintptr_t len = arglen;
+
+                                       if (!argval)
+                                               goto trailer_out;
+
+                                       if (len && argval[len - 1] == ':')
+                                               len--;
+                                       string_list_append(&filter_list, argval)->util = (char *)len;
+
+                                       opts.filter = format_trailer_match_cb;
+                                       opts.filter_data = &filter_list;
                                        opts.only_trailers = 1;
-                               else if (match_placeholder_arg(arg, "unfold", &arg))
-                                       opts.unfold = 1;
-                               else
+                               } else if (!match_placeholder_bool_arg(arg, "only", &arg, &opts.only_trailers) &&
+                                          !match_placeholder_bool_arg(arg, "unfold", &arg, &opts.unfold) &&
+                                          !match_placeholder_bool_arg(arg, "valueonly", &arg, &opts.value_only))
                                        break;
                        }
                }
                if (*arg == ')') {
                        format_trailers_from_commit(sb, msg + c->subject_off, &opts);
-                       return arg - placeholder + 1;
+                       ret = arg - placeholder + 1;
                }
+       trailer_out:
+               string_list_clear(&filter_list, 0);
+               return ret;
        }
 
        return 0;       /* unknown placeholder */