undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'jt/trailer-with-cruft'

Browse Source 
Update "interpret-trailers" machinery and teaches it that people in
real world write all sorts of crufts in the "trailer" that was
originally designed to have the neat-o "Mail-Header: like thing"
and nothing else.

* jt/trailer-with-cruft:
  trailer: support values folded to multiple lines
  trailer: forbid leading whitespace in trailers
  trailer: allow non-trailers in trailer block
  trailer: clarify failure modes in parse_trailer
  trailer: make args have their own struct
  trailer: streamline trailer item create and add
  trailer: use list.h for doubly-linked list
  trailer: improve const correctness
This commit is contained in:
Junio C Hamano 2016-10-31 13:15:22 -07:00
commit cabb79d8c1
3 changed files with 659 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Documentation/git-interpret-trailers.txt
View File

@ -48,19 +48,21 @@ with only spaces at the end of the commit message part, one blank line
will be added before the new trailer.
Existing trailers are extracted from the input message by looking for
a group of one or more lines that contain a colon (by default), where
the group is preceded by one or more empty (or whitespace-only) lines.
a group of one or more lines that (i) are all trailers, or (ii) contains at
least one Git-generated trailer and consists of at least 25% trailers.
The group must be preceded by one or more empty (or whitespace-only) lines.
The group must either be at the end of the message or be the last
non-whitespace lines before a line that starts with '---'. Such three
minus signs start the patch part of the message.
When reading trailers, there can be whitespaces before and after the
When reading trailers, there can be whitespaces after the
token, the separator and the value. There can also be whitespaces
inside the token and the value.
inside the token and the value. The value may be split over multiple lines with
each subsequent line starting with whitespace, like the "folding" in RFC 822.
Note that 'trailers' do not follow and are not intended to follow many
rules for RFC 822 headers. For example they do not follow the line
folding rules, the encoding rules and probably many other rules.
rules for RFC 822 headers. For example they do not follow
the encoding rules and probably many other rules.
OPTIONS
-------

299
t/t7513-interpret-trailers.sh
View File

@ -126,6 +126,305 @@ test_expect_success 'with multiline title in the message' '
test_cmp expected actual
'
test_expect_success 'with non-trailer lines mixed with Signed-off-by' '
cat >patch <<-\EOF &&
this is not a trailer
this is not a trailer
Signed-off-by: a <a@example.com>
this is not a trailer
EOF
cat >expected <<-\EOF &&
this is not a trailer
this is not a trailer
Signed-off-by: a <a@example.com>
this is not a trailer
token: value
EOF
git interpret-trailers --trailer "token: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'with non-trailer lines mixed with cherry picked from' '
cat >patch <<-\EOF &&
this is not a trailer
this is not a trailer
(cherry picked from commit x)
this is not a trailer
EOF
cat >expected <<-\EOF &&
this is not a trailer
this is not a trailer
(cherry picked from commit x)
this is not a trailer
token: value
EOF
git interpret-trailers --trailer "token: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'with non-trailer lines mixed with a configured trailer' '
cat >patch <<-\EOF &&
this is not a trailer
this is not a trailer
My-trailer: x
this is not a trailer
EOF
cat >expected <<-\EOF &&
this is not a trailer
this is not a trailer
My-trailer: x
this is not a trailer
token: value
EOF
test_config trailer.my.key "My-trailer: " &&
git interpret-trailers --trailer "token: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'with non-trailer lines mixed with a non-configured trailer' '
cat >patch <<-\EOF &&
this is not a trailer
this is not a trailer
I-am-not-configured: x
this is not a trailer
EOF
cat >expected <<-\EOF &&
this is not a trailer
this is not a trailer
I-am-not-configured: x
this is not a trailer
token: value
EOF
test_config trailer.my.key "My-trailer: " &&
git interpret-trailers --trailer "token: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'with all non-configured trailers' '
cat >patch <<-\EOF &&
I-am-not-configured: x
I-am-also-not-configured: x
EOF
cat >expected <<-\EOF &&
I-am-not-configured: x
I-am-also-not-configured: x
token: value
EOF
test_config trailer.my.key "My-trailer: " &&
git interpret-trailers --trailer "token: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'with non-trailer lines only' '
cat >patch <<-\EOF &&
this is not a trailer
EOF
cat >expected <<-\EOF &&
this is not a trailer
token: value
EOF
git interpret-trailers --trailer "token: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'line with leading whitespace is not trailer' '
q_to_tab >patch <<-\EOF &&
Qtoken: value
EOF
q_to_tab >expected <<-\EOF &&
Qtoken: value
token: value
EOF
git interpret-trailers --trailer "token: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'multiline field treated as one trailer for 25% check' '
q_to_tab >patch <<-\EOF &&
Signed-off-by: a <a@example.com>
name: value on
Qmultiple lines
this is not a trailer
this is not a trailer
this is not a trailer
this is not a trailer
this is not a trailer
this is not a trailer
EOF
q_to_tab >expected <<-\EOF &&
Signed-off-by: a <a@example.com>
name: value on
Qmultiple lines
this is not a trailer
this is not a trailer
this is not a trailer
this is not a trailer
this is not a trailer
this is not a trailer
name: value
EOF
git interpret-trailers --trailer "name: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'multiline field treated as atomic for placement' '
q_to_tab >patch <<-\EOF &&
another: trailer
name: value on
Qmultiple lines
another: trailer
EOF
q_to_tab >expected <<-\EOF &&
another: trailer
name: value on
Qmultiple lines
name: value
another: trailer
EOF
test_config trailer.name.where after &&
git interpret-trailers --trailer "name: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'multiline field treated as atomic for replacement' '
q_to_tab >patch <<-\EOF &&
another: trailer
name: value on
Qmultiple lines
another: trailer
EOF
q_to_tab >expected <<-\EOF &&
another: trailer
another: trailer
name: value
EOF
test_config trailer.name.ifexists replace &&
git interpret-trailers --trailer "name: value" patch >actual &&
test_cmp expected actual
'
test_expect_success 'multiline field treated as atomic for difference check' '
q_to_tab >patch <<-\EOF &&
another: trailer
name: first line
Qsecond line
another: trailer
EOF
test_config trailer.name.ifexists addIfDifferent &&
q_to_tab >trailer <<-\EOF &&
name: first line
Qsecond line
EOF
q_to_tab >expected <<-\EOF &&
another: trailer
name: first line
Qsecond line
another: trailer
EOF
git interpret-trailers --trailer "$(cat trailer)" patch >actual &&
test_cmp expected actual &&
q_to_tab >trailer <<-\EOF &&
name: first line
QQQQQsecond line
EOF
q_to_tab >expected <<-\EOF &&
another: trailer
name: first line
Qsecond line
another: trailer
name: first line
QQQQQsecond line
EOF
git interpret-trailers --trailer "$(cat trailer)" patch >actual &&
test_cmp expected actual &&
q_to_tab >trailer <<-\EOF &&
name: first line *DIFFERENT*
Qsecond line
EOF
q_to_tab >expected <<-\EOF &&
another: trailer
name: first line
Qsecond line
another: trailer
name: first line *DIFFERENT*
Qsecond line
EOF
git interpret-trailers --trailer "$(cat trailer)" patch >actual &&
test_cmp expected actual
'
test_expect_success 'multiline field treated as atomic for neighbor check' '
q_to_tab >patch <<-\EOF &&
another: trailer
name: first line
Qsecond line
another: trailer
EOF
test_config trailer.name.where after &&
test_config trailer.name.ifexists addIfDifferentNeighbor &&
q_to_tab >trailer <<-\EOF &&
name: first line
Qsecond line
EOF
q_to_tab >expected <<-\EOF &&
another: trailer
name: first line
Qsecond line
another: trailer
EOF
git interpret-trailers --trailer "$(cat trailer)" patch >actual &&
test_cmp expected actual &&
q_to_tab >trailer <<-\EOF &&
name: first line
QQQQQsecond line
EOF
q_to_tab >expected <<-\EOF &&
another: trailer
name: first line
Qsecond line
name: first line
QQQQQsecond line
another: trailer
EOF
git interpret-trailers --trailer "$(cat trailer)" patch >actual &&
test_cmp expected actual
'
test_expect_success 'with config setup' '
git config trailer.ack.key "Acked-by: " &&
cat >expected <<-\EOF &&

630
trailer.c
View File

@ -4,6 +4,7 @@
#include "commit.h"
#include "tempfile.h"
#include "trailer.h"
#include "list.h"
/*
* Copyright (c) 2013, 2014 Christian Couder <chriscool@tuxfamily.org>
*/
@ -25,19 +26,40 @@ struct conf_info {
static struct conf_info default_conf_info;
struct trailer_item {
struct trailer_item *previous;
struct trailer_item *next;
const char *token;
const char *value;
struct list_head list;
/*
* If this is not a trailer line, the line is stored in value
* (excluding the terminating newline) and token is NULL.
*/
char *token;
char *value;
};
struct arg_item {
struct list_head list;
char *token;
char *value;
struct conf_info conf;
};
static struct trailer_item *first_conf_item;
static LIST_HEAD(conf_head);
static char *separators = ":";
#define TRAILER_ARG_STRING "$ARG"
static const char *git_generated_prefixes[] = {
"Signed-off-by: ",
"(cherry picked from commit ",
NULL
};
/* Iterate over the elements of the list. */
#define list_for_each_dir(pos, head, is_reverse) \
for (pos = is_reverse ? (head)->prev : (head)->next; \
pos != (head); \
pos = is_reverse ? pos->prev : pos->next)
static int after_or_end(enum action_where where)
{
return (where == WHERE_AFTER) || (where == WHERE_END);
@ -56,21 +78,26 @@ static size_t token_len_without_separator(const char *token, size_t len)
return len;
}
static int same_token(struct trailer_item *a, struct trailer_item *b)
static int same_token(struct trailer_item *a, struct arg_item *b)
{
size_t a_len = token_len_without_separator(a->token, strlen(a->token));
size_t b_len = token_len_without_separator(b->token, strlen(b->token));
size_t min_len = (a_len > b_len) ? b_len : a_len;
size_t a_len, b_len, min_len;
if (!a->token)
return 0;
a_len = token_len_without_separator(a->token, strlen(a->token));
b_len = token_len_without_separator(b->token, strlen(b->token));
min_len = (a_len > b_len) ? b_len : a_len;
return !strncasecmp(a->token, b->token, min_len);
}
static int same_value(struct trailer_item *a, struct trailer_item *b)
static int same_value(struct trailer_item *a, struct arg_item *b)
{
return !strcasecmp(a->value, b->value);
}
static int same_trailer(struct trailer_item *a, struct trailer_item *b)
static int same_trailer(struct trailer_item *a, struct arg_item *b)
{
return same_token(a, b) && same_value(a, b);
}
@ -91,12 +118,19 @@ static inline void strbuf_replace(struct strbuf *sb, const char *a, const char *
}
static void free_trailer_item(struct trailer_item *item)
{
free(item->token);
free(item->value);
free(item);
}
static void free_arg_item(struct arg_item *item)
{
free(item->conf.name);
free(item->conf.key);
free(item->conf.command);
free((char *)item->token);
free((char *)item->value);
free(item->token);
free(item->value);
free(item);
}
@ -111,7 +145,14 @@ static char last_non_space_char(const char *s)
static void print_tok_val(FILE *outfile, const char *tok, const char *val)
{
char c = last_non_space_char(tok);
char c;
if (!tok) {
fprintf(outfile, "%s\n", val);
return;
}
c = last_non_space_char(tok);
if (!c)
return;
if (strchr(separators, c))
@ -120,108 +161,68 @@ static void print_tok_val(FILE *outfile, const char *tok, const char *val)
fprintf(outfile, "%s%c %s\n", tok, separators[0], val);
}
static void print_all(FILE *outfile, struct trailer_item *first, int trim_empty)
static void print_all(FILE *outfile, struct list_head *head, int trim_empty)
{
struct list_head *pos;
struct trailer_item *item;
for (item = first; item; item = item->next) {
list_for_each(pos, head) {
item = list_entry(pos, struct trailer_item, list);
if (!trim_empty || strlen(item->value) > 0)
print_tok_val(outfile, item->token, item->value);
}
}
static void update_last(struct trailer_item **last)
static struct trailer_item *trailer_from_arg(struct arg_item *arg_tok)
{
if (*last)
while ((*last)->next != NULL)
*last = (*last)->next;
}
static void update_first(struct trailer_item **first)
{
if (*first)
while ((*first)->previous != NULL)
*first = (*first)->previous;
struct trailer_item *new = xcalloc(sizeof(*new), 1);
new->token = arg_tok->token;
new->value = arg_tok->value;
arg_tok->token = arg_tok->value = NULL;
free_arg_item(arg_tok);
return new;
}
static void add_arg_to_input_list(struct trailer_item *on_tok,
struct trailer_item *arg_tok,
struct trailer_item **first,
struct trailer_item **last)
struct arg_item *arg_tok)
{
if (after_or_end(arg_tok->conf.where)) {
arg_tok->next = on_tok->next;
on_tok->next = arg_tok;
arg_tok->previous = on_tok;
if (arg_tok->next)
arg_tok->next->previous = arg_tok;
update_last(last);
} else {
arg_tok->previous = on_tok->previous;
on_tok->previous = arg_tok;
arg_tok->next = on_tok;
if (arg_tok->previous)
arg_tok->previous->next = arg_tok;
update_first(first);
}
int aoe = after_or_end(arg_tok->conf.where);
struct trailer_item *to_add = trailer_from_arg(arg_tok);
if (aoe)
list_add(&to_add->list, &on_tok->list);
else
list_add_tail(&to_add->list, &on_tok->list);
}
static int check_if_different(struct trailer_item *in_tok,
struct trailer_item *arg_tok,
int check_all)
struct arg_item *arg_tok,
int check_all,
struct list_head *head)
{
enum action_where where = arg_tok->conf.where;
struct list_head *next_head;
do {
if (!in_tok)
return 1;
if (same_trailer(in_tok, arg_tok))
return 0;
/*
* if we want to add a trailer after another one,
* we have to check those before this one
*/
in_tok = after_or_end(where) ? in_tok->previous : in_tok->next;
next_head = after_or_end(where) ? in_tok->list.prev
: in_tok->list.next;
if (next_head == head)
break;
in_tok = list_entry(next_head, struct trailer_item, list);
} while (check_all);
return 1;
}
static void remove_from_list(struct trailer_item *item,
struct trailer_item **first,
struct trailer_item **last)
{
struct trailer_item *next = item->next;
struct trailer_item *previous = item->previous;
if (next) {
item->next->previous = previous;
item->next = NULL;
} else if (last)
*last = previous;
if (previous) {
item->previous->next = next;
item->previous = NULL;
} else if (first)
*first = next;
}
static struct trailer_item *remove_first(struct trailer_item **first)
{
struct trailer_item *item = *first;
*first = item->next;
if (item->next) {
item->next->previous = NULL;
item->next = NULL;
}
return item;
}
static const char *apply_command(const char *command, const char *arg)
static char *apply_command(const char *command, const char *arg)
{
struct strbuf cmd = STRBUF_INIT;
struct strbuf buf = STRBUF_INIT;
struct child_process cp = CHILD_PROCESS_INIT;
const char *argv[] = {NULL, NULL};
const char *result;
char *result;
strbuf_addstr(&cmd, command);
if (arg)
@ -246,7 +247,7 @@ static const char *apply_command(const char *command, const char *arg)
return result;
}
static void apply_item_command(struct trailer_item *in_tok, struct trailer_item *arg_tok)
static void apply_item_command(struct trailer_item *in_tok, struct arg_item *arg_tok)
{
if (arg_tok->conf.command) {
const char *arg;
@ -264,121 +265,108 @@ static void apply_item_command(struct trailer_item *in_tok, struct trailer_item
}
static void apply_arg_if_exists(struct trailer_item *in_tok,
struct trailer_item *arg_tok,
struct arg_item *arg_tok,
struct trailer_item *on_tok,
struct trailer_item **in_tok_first,
struct trailer_item **in_tok_last)
struct list_head *head)
{
switch (arg_tok->conf.if_exists) {
case EXISTS_DO_NOTHING:
free_trailer_item(arg_tok);
free_arg_item(arg_tok);
break;
case EXISTS_REPLACE:
apply_item_command(in_tok, arg_tok);
add_arg_to_input_list(on_tok, arg_tok,
in_tok_first, in_tok_last);
remove_from_list(in_tok, in_tok_first, in_tok_last);
add_arg_to_input_list(on_tok, arg_tok);
list_del(&in_tok->list);
free_trailer_item(in_tok);
break;
case EXISTS_ADD:
apply_item_command(in_tok, arg_tok);
add_arg_to_input_list(on_tok, arg_tok,
in_tok_first, in_tok_last);
add_arg_to_input_list(on_tok, arg_tok);
break;
case EXISTS_ADD_IF_DIFFERENT:
apply_item_command(in_tok, arg_tok);
if (check_if_different(in_tok, arg_tok, 1))
add_arg_to_input_list(on_tok, arg_tok,
in_tok_first, in_tok_last);
if (check_if_different(in_tok, arg_tok, 1, head))
add_arg_to_input_list(on_tok, arg_tok);
else
free_trailer_item(arg_tok);
free_arg_item(arg_tok);
break;
case EXISTS_ADD_IF_DIFFERENT_NEIGHBOR:
apply_item_command(in_tok, arg_tok);
if (check_if_different(on_tok, arg_tok, 0))
add_arg_to_input_list(on_tok, arg_tok,
in_tok_first, in_tok_last);
if (check_if_different(on_tok, arg_tok, 0, head))
add_arg_to_input_list(on_tok, arg_tok);
else
free_trailer_item(arg_tok);
free_arg_item(arg_tok);
break;
}
}
static void apply_arg_if_missing(struct trailer_item **in_tok_first,
struct trailer_item **in_tok_last,
struct trailer_item *arg_tok)
static void apply_arg_if_missing(struct list_head *head,
struct arg_item *arg_tok)
{
struct trailer_item **in_tok;
enum action_where where;
struct trailer_item *to_add;
switch (arg_tok->conf.if_missing) {
case MISSING_DO_NOTHING:
free_trailer_item(arg_tok);
free_arg_item(arg_tok);
break;
case MISSING_ADD:
where = arg_tok->conf.where;
in_tok = after_or_end(where) ? in_tok_last : in_tok_first;
apply_item_command(NULL, arg_tok);
if (*in_tok) {
add_arg_to_input_list(*in_tok, arg_tok,
in_tok_first, in_tok_last);
} else {
*in_tok_first = arg_tok;
*in_tok_last = arg_tok;
}
break;
to_add = trailer_from_arg(arg_tok);
if (after_or_end(where))
list_add_tail(&to_add->list, head);
else
list_add(&to_add->list, head);
}
}
static int find_same_and_apply_arg(struct trailer_item **in_tok_first,
struct trailer_item **in_tok_last,
struct trailer_item *arg_tok)
static int find_same_and_apply_arg(struct list_head *head,
struct arg_item *arg_tok)
{
struct list_head *pos;
struct trailer_item *in_tok;
struct trailer_item *on_tok;
struct trailer_item *following_tok;
enum action_where where = arg_tok->conf.where;
int middle = (where == WHERE_AFTER) || (where == WHERE_BEFORE);
int backwards = after_or_end(where);
struct trailer_item *start_tok = backwards ? *in_tok_last : *in_tok_first;
struct trailer_item *start_tok;
for (in_tok = start_tok; in_tok; in_tok = following_tok) {
following_tok = backwards ? in_tok->previous : in_tok->next;
if (list_empty(head))
return 0;
start_tok = list_entry(backwards ? head->prev : head->next,
struct trailer_item,
list);
list_for_each_dir(pos, head, backwards) {
in_tok = list_entry(pos, struct trailer_item, list);
if (!same_token(in_tok, arg_tok))
continue;
on_tok = middle ? in_tok : start_tok;
apply_arg_if_exists(in_tok, arg_tok, on_tok,
in_tok_first, in_tok_last);
apply_arg_if_exists(in_tok, arg_tok, on_tok, head);
return 1;
}
return 0;
}
static void process_trailers_lists(struct trailer_item **in_tok_first,
struct trailer_item **in_tok_last,
struct trailer_item **arg_tok_first)
static void process_trailers_lists(struct list_head *head,
struct list_head *arg_head)
{
struct trailer_item *arg_tok;
struct trailer_item *next_arg;
struct list_head *pos, *p;
struct arg_item *arg_tok;
if (!*arg_tok_first)
return;
for (arg_tok = *arg_tok_first; arg_tok; arg_tok = next_arg) {
list_for_each_safe(pos, p, arg_head) {
int applied = 0;
arg_tok = list_entry(pos, struct arg_item, list);
next_arg = arg_tok->next;
remove_from_list(arg_tok, arg_tok_first, NULL);
list_del(pos);
applied = find_same_and_apply_arg(in_tok_first,
in_tok_last,
arg_tok);
applied = find_same_and_apply_arg(head, arg_tok);
if (!applied)
apply_arg_if_missing(in_tok_first,
in_tok_last,
arg_tok);
apply_arg_if_missing(head, arg_tok);
}
}
@ -425,7 +413,7 @@ static int set_if_missing(struct conf_info *item, const char *value)
return 0;
}
static void duplicate_conf(struct conf_info *dst, struct conf_info *src)
static void duplicate_conf(struct conf_info *dst, const struct conf_info *src)
{
*dst = *src;
dst->name = xstrdup_or_null(src->name);
@ -433,30 +421,24 @@ static void duplicate_conf(struct conf_info *dst, struct conf_info *src)
dst->command = xstrdup_or_null(src->command);
}
static struct trailer_item *get_conf_item(const char *name)
static struct arg_item *get_conf_item(const char *name)
{
struct trailer_item *item;
struct trailer_item *previous;
struct list_head *pos;
struct arg_item *item;
/* Look up item with same name */
for (previous = NULL, item = first_conf_item;
item;
previous = item, item = item->next) {
list_for_each(pos, &conf_head) {
item = list_entry(pos, struct arg_item, list);
if (!strcasecmp(item->conf.name, name))
return item;
}
/* Item does not already exists, create it */
item = xcalloc(sizeof(struct trailer_item), 1);
item = xcalloc(sizeof(*item), 1);
duplicate_conf(&item->conf, &default_conf_info);
item->conf.name = xstrdup(name);
if (!previous)
first_conf_item = item;
else {
previous->next = item;
item->previous = previous;
}
list_add_tail(&item->list, &conf_head);
return item;
}
@ -506,7 +488,7 @@ static int git_trailer_default_config(const char *conf_key, const char *value, v
static int git_trailer_config(const char *conf_key, const char *value, void *cb)
{
const char *trailer_item, *variable_name;
struct trailer_item *item;
struct arg_item *item;
struct conf_info *conf;
char *name = NULL;
enum trailer_info_type type;
@ -564,33 +546,7 @@ static int git_trailer_config(const char *conf_key, const char *value, void *cb)
return 0;
}
static int parse_trailer(struct strbuf *tok, struct strbuf *val, const char *trailer)
{
size_t len;
struct strbuf seps = STRBUF_INIT;
strbuf_addstr(&seps, separators);
strbuf_addch(&seps, '=');
len = strcspn(trailer, seps.buf);
strbuf_release(&seps);
if (len == 0) {
int l = strlen(trailer);
while (l > 0 && isspace(trailer[l - 1]))
l--;
return error(_("empty trailer token in trailer '%.*s'"), l, trailer);
}
if (len < strlen(trailer)) {
strbuf_add(tok, trailer, len);
strbuf_trim(tok);
strbuf_addstr(val, trailer + len + 1);
strbuf_trim(val);
} else {
strbuf_addstr(tok, trailer);
strbuf_trim(tok);
}
return 0;
}
static const char *token_from_item(struct trailer_item *item, char *tok)
static const char *token_from_item(struct arg_item *item, char *tok)
{
if (item->conf.key)
return item->conf.key;
@ -599,94 +555,134 @@ static const char *token_from_item(struct trailer_item *item, char *tok)
return item->conf.name;
}
static struct trailer_item *new_trailer_item(struct trailer_item *conf_item,
char *tok, char *val)
{
struct trailer_item *new = xcalloc(sizeof(*new), 1);
new->value = val ? val : xstrdup("");
if (conf_item) {
duplicate_conf(&new->conf, &conf_item->conf);
new->token = xstrdup(token_from_item(conf_item, tok));
free(tok);
} else {
duplicate_conf(&new->conf, &default_conf_info);
new->token = tok;
}
return new;
}
static int token_matches_item(const char *tok, struct trailer_item *item, int tok_len)
static int token_matches_item(const char *tok, struct arg_item *item, int tok_len)
{
if (!strncasecmp(tok, item->conf.name, tok_len))
return 1;
return item->conf.key ? !strncasecmp(tok, item->conf.key, tok_len) : 0;
}
static struct trailer_item *create_trailer_item(const char *string)
/*
* Return the location of the first separator in line, or -1 if there is no
* separator.
*/
static int find_separator(const char *line, const char *separators)
{
struct strbuf tok = STRBUF_INIT;
struct strbuf val = STRBUF_INIT;
struct trailer_item *item;
int loc = strcspn(line, separators);
if (!line[loc])
return -1;
return loc;
}
/*
* Obtain the token, value, and conf from the given trailer.
*
* separator_pos must not be 0, since the token cannot be an empty string.
*
* If separator_pos is -1, interpret the whole trailer as a token.
*/
static void parse_trailer(struct strbuf *tok, struct strbuf *val,
const struct conf_info **conf, const char *trailer,
int separator_pos)
{
struct arg_item *item;
int tok_len;
struct list_head *pos;
if (parse_trailer(&tok, &val, string))
return NULL;
tok_len = token_len_without_separator(tok.buf, tok.len);
if (separator_pos != -1) {
strbuf_add(tok, trailer, separator_pos);
strbuf_trim(tok);
strbuf_addstr(val, trailer + separator_pos + 1);
strbuf_trim(val);
} else {
strbuf_addstr(tok, trailer);
strbuf_trim(tok);
}
/* Lookup if the token matches something in the config */
for (item = first_conf_item; item; item = item->next) {
if (token_matches_item(tok.buf, item, tok_len))
return new_trailer_item(item,
strbuf_detach(&tok, NULL),
strbuf_detach(&val, NULL));
}
return new_trailer_item(NULL,
strbuf_detach(&tok, NULL),
strbuf_detach(&val, NULL));
}
static void add_trailer_item(struct trailer_item **first,
struct trailer_item **last,
struct trailer_item *new)
{
if (!new)
return;
if (!*last) {
*first = new;
*last = new;
} else {
(*last)->next = new;
new->previous = *last;
*last = new;
tok_len = token_len_without_separator(tok->buf, tok->len);
if (conf)
*conf = &default_conf_info;
list_for_each(pos, &conf_head) {
item = list_entry(pos, struct arg_item, list);
if (token_matches_item(tok->buf, item, tok_len)) {
char *tok_buf = strbuf_detach(tok, NULL);
if (conf)
*conf = &item->conf;
strbuf_addstr(tok, token_from_item(item, tok_buf));
free(tok_buf);
break;
}
}
}
static struct trailer_item *process_command_line_args(struct string_list *trailers)
static struct trailer_item *add_trailer_item(struct list_head *head, char *tok,
char *val)
{
struct trailer_item *new = xcalloc(sizeof(*new), 1);
new->token = tok;
new->value = val;
list_add_tail(&new->list, head);
return new;
}
static void add_arg_item(struct list_head *arg_head, char *tok, char *val,
const struct conf_info *conf)
{
struct arg_item *new = xcalloc(sizeof(*new), 1);
new->token = tok;
new->value = val;
duplicate_conf(&new->conf, conf);
list_add_tail(&new->list, arg_head);
}
static void process_command_line_args(struct list_head *arg_head,
struct string_list *trailers)
{
struct trailer_item *arg_tok_first = NULL;
struct trailer_item *arg_tok_last = NULL;
struct string_list_item *tr;
struct trailer_item *item;
struct arg_item *item;
struct strbuf tok = STRBUF_INIT;
struct strbuf val = STRBUF_INIT;
const struct conf_info *conf;
struct list_head *pos;
/* Add a trailer item for each configured trailer with a command */
for (item = first_conf_item; item; item = item->next) {
if (item->conf.command) {
struct trailer_item *new = new_trailer_item(item, NULL, NULL);
add_trailer_item(&arg_tok_first, &arg_tok_last, new);
/*
* In command-line arguments, '=' is accepted (in addition to the
* separators that are defined).
*/
char *cl_separators = xstrfmt("=%s", separators);
/* Add an arg item for each configured trailer with a command */
list_for_each(pos, &conf_head) {
item = list_entry(pos, struct arg_item, list);
if (item->conf.command)
add_arg_item(arg_head,
xstrdup(token_from_item(item, NULL)),
xstrdup(""),
&item->conf);
}
/* Add an arg item for each trailer on the command line */
for_each_string_list_item(tr, trailers) {
int separator_pos = find_separator(tr->string, cl_separators);
if (separator_pos == 0) {
struct strbuf sb = STRBUF_INIT;
strbuf_addstr(&sb, tr->string);
strbuf_trim(&sb);
error(_("empty trailer token in trailer '%.*s'"),
(int) sb.len, sb.buf);
strbuf_release(&sb);
} else {
parse_trailer(&tok, &val, &conf, tr->string,
separator_pos);
add_arg_item(arg_head,
strbuf_detach(&tok, NULL),
strbuf_detach(&val, NULL),
conf);
}
}
/* Add a trailer item for each trailer on the command line */
for_each_string_list_item(tr, trailers) {
struct trailer_item *new = create_trailer_item(tr->string);
add_trailer_item(&arg_tok_first, &arg_tok_last, new);
}
return arg_tok_first;
free(cl_separators);
}
static struct strbuf **read_input_file(const char *file)
@ -734,6 +730,15 @@ static int find_patch_start(struct strbuf **lines, int count)
static int find_trailer_start(struct strbuf **lines, int count)
{
int start, end_of_title, only_spaces = 1;
int recognized_prefix = 0, trailer_lines = 0, non_trailer_lines = 0;
/*
* Number of possible continuation lines encountered. This will be
* reset to 0 if we encounter a trailer (since those lines are to be
* considered continuations of that trailer), and added to
* non_trailer_lines if we encounter a non-trailer (since those lines
* are to be considered non-trailers).
*/
int possible_continuation_lines = 0;
/* The first paragraph is the title and cannot be trailers */
for (start = 0; start < count; start++) {
@ -745,26 +750,71 @@ static int find_trailer_start(struct strbuf **lines, int count)
end_of_title = start;
/*
* Get the start of the trailers by looking starting from the end
* for a line with only spaces before lines with one separator.
* Get the start of the trailers by looking starting from the end for a
* blank line before a set of non-blank lines that (i) are all
* trailers, or (ii) contains at least one Git-generated trailer and
* consists of at least 25% trailers.
*/
for (start = count - 1; start >= end_of_title; start--) {
if (lines[start]->buf[0] == comment_line_char)
const char **p;
int separator_pos;
if (lines[start]->buf[0] == comment_line_char) {
non_trailer_lines += possible_continuation_lines;
possible_continuation_lines = 0;
continue;
}
if (contains_only_spaces(lines[start]->buf)) {
if (only_spaces)
continue;
return start + 1;
non_trailer_lines += possible_continuation_lines;
if (recognized_prefix &&
trailer_lines * 3 >= non_trailer_lines)
return start + 1;
if (trailer_lines && !non_trailer_lines)
return start + 1;
return count;
}
if (strcspn(lines[start]->buf, separators) < lines[start]->len) {
if (only_spaces)
only_spaces = 0;
continue;
only_spaces = 0;
for (p = git_generated_prefixes; *p; p++) {
if (starts_with(lines[start]->buf, *p)) {
trailer_lines++;
possible_continuation_lines = 0;
recognized_prefix = 1;
goto continue_outer_loop;
}
}
return count;
separator_pos = find_separator(lines[start]->buf, separators);
if (separator_pos >= 1 && !isspace(lines[start]->buf[0])) {
struct list_head *pos;
trailer_lines++;
possible_continuation_lines = 0;
if (recognized_prefix)
continue;
list_for_each(pos, &conf_head) {
struct arg_item *item;
item = list_entry(pos, struct arg_item, list);
if (token_matches_item(lines[start]->buf, item,
separator_pos)) {
recognized_prefix = 1;
break;
}
}
} else if (isspace(lines[start]->buf[0]))
possible_continuation_lines++;
else {
non_trailer_lines++;
non_trailer_lines += possible_continuation_lines;
possible_continuation_lines = 0;
}
continue_outer_loop:
;
}
return only_spaces ? count : 0;
return count;
}
/* Get the index of the end of the trailers */
@ -802,11 +852,13 @@ static void print_lines(FILE *outfile, struct strbuf **lines, int start, int end
static int process_input_file(FILE *outfile,
struct strbuf **lines,
struct trailer_item **in_tok_first,
struct trailer_item **in_tok_last)
struct list_head *head)
{
int count = 0;
int patch_start, trailer_start, trailer_end, i;
struct strbuf tok = STRBUF_INIT;
struct strbuf val = STRBUF_INIT;
struct trailer_item *last = NULL;
/* Get the line count */
while (lines[count])
@ -824,20 +876,43 @@ static int process_input_file(FILE *outfile,
/* Parse trailer lines */
for (i = trailer_start; i < trailer_end; i++) {
if (lines[i]->buf[0] != comment_line_char) {
struct trailer_item *new = create_trailer_item(lines[i]->buf);
add_trailer_item(in_tok_first, in_tok_last, new);
int separator_pos;
if (lines[i]->buf[0] == comment_line_char)
continue;
if (last && isspace(lines[i]->buf[0])) {
struct strbuf sb = STRBUF_INIT;
strbuf_addf(&sb, "%s\n%s", last->value, lines[i]->buf);
strbuf_strip_suffix(&sb, "\n");
free(last->value);
last->value = strbuf_detach(&sb, NULL);
continue;
}
separator_pos = find_separator(lines[i]->buf, separators);
if (separator_pos >= 1) {
parse_trailer(&tok, &val, NULL, lines[i]->buf,
separator_pos);
last = add_trailer_item(head,
strbuf_detach(&tok, NULL),
strbuf_detach(&val, NULL));
} else {
strbuf_addbuf(&val, lines[i]);
strbuf_strip_suffix(&val, "\n");
add_trailer_item(head,
NULL,
strbuf_detach(&val, NULL));
last = NULL;
}
}
return trailer_end;
}
static void free_all(struct trailer_item **first)
static void free_all(struct list_head *head)
{
while (*first) {
struct trailer_item *item = remove_first(first);
free_trailer_item(item);
struct list_head *pos, *p;
list_for_each_safe(pos, p, head) {
list_del(pos);
free_trailer_item(list_entry(pos, struct trailer_item, list));
}
}
@ -874,9 +949,8 @@ static FILE *create_in_place_tempfile(const char *file)
void process_trailers(const char *file, int in_place, int trim_empty, struct string_list *trailers)
{
struct trailer_item *in_tok_first = NULL;
struct trailer_item *in_tok_last = NULL;
struct trailer_item *arg_tok_first;
LIST_HEAD(head);
LIST_HEAD(arg_head);
struct strbuf **lines;
int trailer_end;
FILE *outfile = stdout;
@ -891,15 +965,15 @@ void process_trailers(const char *file, int in_place, int trim_empty, struct str
outfile = create_in_place_tempfile(file);
/* Print the lines before the trailers */
trailer_end = process_input_file(outfile, lines, &in_tok_first, &in_tok_last);
trailer_end = process_input_file(outfile, lines, &head);
arg_tok_first = process_command_line_args(trailers);
process_command_line_args(&arg_head, trailers);
process_trailers_lists(&in_tok_first, &in_tok_last, &arg_tok_first);
process_trailers_lists(&head, &arg_head);
print_all(outfile, in_tok_first, trim_empty);
print_all(outfile, &head, trim_empty);
free_all(&in_tok_first);
free_all(&head);
/* Print the lines after the trailers as is */
print_lines(outfile, lines, trailer_end, INT_MAX);