diff options
Diffstat (limited to 'trailer.c')
| -rw-r--r-- | trailer.c | 850 |
1 files changed, 850 insertions, 0 deletions
diff --git a/trailer.c b/trailer.c new file mode 100644 index 0000000000..6ae786505a --- /dev/null +++ b/trailer.c @@ -0,0 +1,850 @@ +#include "cache.h" +#include "string-list.h" +#include "run-command.h" +#include "string-list.h" +#include "trailer.h" +/* + * Copyright (c) 2013, 2014 Christian Couder <chriscool@tuxfamily.org> + */ + +enum action_where { WHERE_END, WHERE_AFTER, WHERE_BEFORE, WHERE_START }; +enum action_if_exists { EXISTS_ADD_IF_DIFFERENT_NEIGHBOR, EXISTS_ADD_IF_DIFFERENT, + EXISTS_ADD, EXISTS_REPLACE, EXISTS_DO_NOTHING }; +enum action_if_missing { MISSING_ADD, MISSING_DO_NOTHING }; + +struct conf_info { + char *name; + char *key; + char *command; + enum action_where where; + enum action_if_exists if_exists; + enum action_if_missing if_missing; +}; + +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 conf_info conf; +}; + +static struct trailer_item *first_conf_item; + +static char *separators = ":"; + +#define TRAILER_ARG_STRING "$ARG" + +static int after_or_end(enum action_where where) +{ + return (where == WHERE_AFTER) || (where == WHERE_END); +} + +/* + * Return the length of the string not including any final + * punctuation. E.g., the input "Signed-off-by:" would return + * 13, stripping the trailing punctuation but retaining + * internal punctuation. + */ +static size_t token_len_without_separator(const char *token, size_t len) +{ + while (len > 0 && !isalnum(token[len - 1])) + len--; + return len; +} + +static int same_token(struct trailer_item *a, struct trailer_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; + + return !strncasecmp(a->token, b->token, min_len); +} + +static int same_value(struct trailer_item *a, struct trailer_item *b) +{ + return !strcasecmp(a->value, b->value); +} + +static int same_trailer(struct trailer_item *a, struct trailer_item *b) +{ + return same_token(a, b) && same_value(a, b); +} + +static inline int contains_only_spaces(const char *str) +{ + const char *s = str; + while (*s && isspace(*s)) + s++; + return !*s; +} + +static inline void strbuf_replace(struct strbuf *sb, const char *a, const char *b) +{ + const char *ptr = strstr(sb->buf, a); + if (ptr) + strbuf_splice(sb, ptr - sb->buf, strlen(a), b, strlen(b)); +} + +static void free_trailer_item(struct trailer_item *item) +{ + free(item->conf.name); + free(item->conf.key); + free(item->conf.command); + free((char *)item->token); + free((char *)item->value); + free(item); +} + +static char last_non_space_char(const char *s) +{ + int i; + for (i = strlen(s) - 1; i >= 0; i--) + if (!isspace(s[i])) + return s[i]; + return '\0'; +} + +static void print_tok_val(const char *tok, const char *val) +{ + char c = last_non_space_char(tok); + if (!c) + return; + if (strchr(separators, c)) + printf("%s%s\n", tok, val); + else + printf("%s%c %s\n", tok, separators[0], val); +} + +static void print_all(struct trailer_item *first, int trim_empty) +{ + struct trailer_item *item; + for (item = first; item; item = item->next) { + if (!trim_empty || strlen(item->value) > 0) + print_tok_val(item->token, item->value); + } +} + +static void update_last(struct trailer_item **last) +{ + 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; +} + +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) +{ + 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); + } +} + +static int check_if_different(struct trailer_item *in_tok, + struct trailer_item *arg_tok, + int check_all) +{ + enum action_where where = arg_tok->conf.where; + 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; + } 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 int read_from_command(struct child_process *cp, struct strbuf *buf) +{ + if (run_command(cp)) + return error("running trailer command '%s' failed", cp->argv[0]); + if (strbuf_read(buf, cp->out, 1024) < 1) + return error("reading from trailer command '%s' failed", cp->argv[0]); + strbuf_trim(buf); + return 0; +} + +static const 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; + + strbuf_addstr(&cmd, command); + if (arg) + strbuf_replace(&cmd, TRAILER_ARG_STRING, arg); + + argv[0] = cmd.buf; + cp.argv = argv; + cp.env = local_repo_env; + cp.no_stdin = 1; + cp.out = -1; + cp.use_shell = 1; + + if (read_from_command(&cp, &buf)) { + strbuf_release(&buf); + result = xstrdup(""); + } else + result = strbuf_detach(&buf, NULL); + + strbuf_release(&cmd); + return result; +} + +static void apply_item_command(struct trailer_item *in_tok, struct trailer_item *arg_tok) +{ + if (arg_tok->conf.command) { + const char *arg; + if (arg_tok->value && arg_tok->value[0]) { + arg = arg_tok->value; + } else { + if (in_tok && in_tok->value) + arg = xstrdup(in_tok->value); + else + arg = xstrdup(""); + } + arg_tok->value = apply_command(arg_tok->conf.command, arg); + free((char *)arg); + } +} + +static void apply_arg_if_exists(struct trailer_item *in_tok, + struct trailer_item *arg_tok, + struct trailer_item *on_tok, + struct trailer_item **in_tok_first, + struct trailer_item **in_tok_last) +{ + switch (arg_tok->conf.if_exists) { + case EXISTS_DO_NOTHING: + free_trailer_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); + 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); + 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); + else + free_trailer_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); + else + free_trailer_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) +{ + struct trailer_item **in_tok; + enum action_where where; + + switch (arg_tok->conf.if_missing) { + case MISSING_DO_NOTHING: + free_trailer_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; + } +} + +static int find_same_and_apply_arg(struct trailer_item **in_tok_first, + struct trailer_item **in_tok_last, + struct trailer_item *arg_tok) +{ + 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; + + for (in_tok = start_tok; in_tok; in_tok = following_tok) { + following_tok = backwards ? in_tok->previous : in_tok->next; + 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); + 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) +{ + struct trailer_item *arg_tok; + struct trailer_item *next_arg; + + if (!*arg_tok_first) + return; + + for (arg_tok = *arg_tok_first; arg_tok; arg_tok = next_arg) { + int applied = 0; + + next_arg = arg_tok->next; + remove_from_list(arg_tok, arg_tok_first, NULL); + + applied = find_same_and_apply_arg(in_tok_first, + in_tok_last, + arg_tok); + + if (!applied) + apply_arg_if_missing(in_tok_first, + in_tok_last, + arg_tok); + } +} + +static int set_where(struct conf_info *item, const char *value) +{ + if (!strcasecmp("after", value)) + item->where = WHERE_AFTER; + else if (!strcasecmp("before", value)) + item->where = WHERE_BEFORE; + else if (!strcasecmp("end", value)) + item->where = WHERE_END; + else if (!strcasecmp("start", value)) + item->where = WHERE_START; + else + return -1; + return 0; +} + +static int set_if_exists(struct conf_info *item, const char *value) +{ + if (!strcasecmp("addIfDifferent", value)) + item->if_exists = EXISTS_ADD_IF_DIFFERENT; + else if (!strcasecmp("addIfDifferentNeighbor", value)) + item->if_exists = EXISTS_ADD_IF_DIFFERENT_NEIGHBOR; + else if (!strcasecmp("add", value)) + item->if_exists = EXISTS_ADD; + else if (!strcasecmp("replace", value)) + item->if_exists = EXISTS_REPLACE; + else if (!strcasecmp("doNothing", value)) + item->if_exists = EXISTS_DO_NOTHING; + else + return -1; + return 0; +} + +static int set_if_missing(struct conf_info *item, const char *value) +{ + if (!strcasecmp("doNothing", value)) + item->if_missing = MISSING_DO_NOTHING; + else if (!strcasecmp("add", value)) + item->if_missing = MISSING_ADD; + else + return -1; + return 0; +} + +static void duplicate_conf(struct conf_info *dst, struct conf_info *src) +{ + *dst = *src; + if (src->name) + dst->name = xstrdup(src->name); + if (src->key) + dst->key = xstrdup(src->key); + if (src->command) + dst->command = xstrdup(src->command); +} + +static struct trailer_item *get_conf_item(const char *name) +{ + struct trailer_item *item; + struct trailer_item *previous; + + /* Look up item with same name */ + for (previous = NULL, item = first_conf_item; + item; + previous = item, item = item->next) { + if (!strcasecmp(item->conf.name, name)) + return item; + } + + /* Item does not already exists, create it */ + item = xcalloc(sizeof(struct trailer_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; + } + + return item; +} + +enum trailer_info_type { TRAILER_KEY, TRAILER_COMMAND, TRAILER_WHERE, + TRAILER_IF_EXISTS, TRAILER_IF_MISSING }; + +static struct { + const char *name; + enum trailer_info_type type; +} trailer_config_items[] = { + { "key", TRAILER_KEY }, + { "command", TRAILER_COMMAND }, + { "where", TRAILER_WHERE }, + { "ifexists", TRAILER_IF_EXISTS }, + { "ifmissing", TRAILER_IF_MISSING } +}; + +static int git_trailer_default_config(const char *conf_key, const char *value, void *cb) +{ + const char *trailer_item, *variable_name; + + if (!skip_prefix(conf_key, "trailer.", &trailer_item)) + return 0; + + variable_name = strrchr(trailer_item, '.'); + if (!variable_name) { + if (!strcmp(trailer_item, "where")) { + if (set_where(&default_conf_info, value) < 0) + warning(_("unknown value '%s' for key '%s'"), + value, conf_key); + } else if (!strcmp(trailer_item, "ifexists")) { + if (set_if_exists(&default_conf_info, value) < 0) + warning(_("unknown value '%s' for key '%s'"), + value, conf_key); + } else if (!strcmp(trailer_item, "ifmissing")) { + if (set_if_missing(&default_conf_info, value) < 0) + warning(_("unknown value '%s' for key '%s'"), + value, conf_key); + } else if (!strcmp(trailer_item, "separators")) { + separators = xstrdup(value); + } + } + return 0; +} + +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 conf_info *conf; + char *name = NULL; + enum trailer_info_type type; + int i; + + if (!skip_prefix(conf_key, "trailer.", &trailer_item)) + return 0; + + variable_name = strrchr(trailer_item, '.'); + if (!variable_name) + return 0; + + variable_name++; + for (i = 0; i < ARRAY_SIZE(trailer_config_items); i++) { + if (strcmp(trailer_config_items[i].name, variable_name)) + continue; + name = xstrndup(trailer_item, variable_name - trailer_item - 1); + type = trailer_config_items[i].type; + break; + } + + if (!name) + return 0; + + item = get_conf_item(name); + conf = &item->conf; + free(name); + + switch (type) { + case TRAILER_KEY: + if (conf->key) + warning(_("more than one %s"), conf_key); + conf->key = xstrdup(value); + break; + case TRAILER_COMMAND: + if (conf->command) + warning(_("more than one %s"), conf_key); + conf->command = xstrdup(value); + break; + case TRAILER_WHERE: + if (set_where(conf, value)) + warning(_("unknown value '%s' for key '%s'"), value, conf_key); + break; + case TRAILER_IF_EXISTS: + if (set_if_exists(conf, value)) + warning(_("unknown value '%s' for key '%s'"), value, conf_key); + break; + case TRAILER_IF_MISSING: + if (set_if_missing(conf, value)) + warning(_("unknown value '%s' for key '%s'"), value, conf_key); + break; + default: + die("internal bug in trailer.c"); + } + 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) + return error(_("empty trailer token in trailer '%s'"), 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) +{ + if (item->conf.key) + return item->conf.key; + if (tok) + return 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) +{ + 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) +{ + struct strbuf tok = STRBUF_INIT; + struct strbuf val = STRBUF_INIT; + struct trailer_item *item; + int tok_len; + + if (parse_trailer(&tok, &val, string)) + return NULL; + + tok_len = token_len_without_separator(tok.buf, tok.len); + + /* 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; + } +} + +static struct trailer_item *process_command_line_args(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; + + /* 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); + } + } + + /* 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; +} + +static struct strbuf **read_input_file(const char *file) +{ + struct strbuf **lines; + struct strbuf sb = STRBUF_INIT; + + if (file) { + if (strbuf_read_file(&sb, file, 0) < 0) + die_errno(_("could not read input file '%s'"), file); + } else { + if (strbuf_read(&sb, fileno(stdin), 0) < 0) + die_errno(_("could not read from stdin")); + } + + lines = strbuf_split(&sb, '\n'); + + strbuf_release(&sb); + + return lines; +} + +/* + * Return the (0 based) index of the start of the patch or the line + * count if there is no patch in the message. + */ +static int find_patch_start(struct strbuf **lines, int count) +{ + int i; + + /* Get the start of the patch part if any */ + for (i = 0; i < count; i++) { + if (starts_with(lines[i]->buf, "---")) + return i; + } + + return count; +} + +/* + * Return the (0 based) index of the first trailer line or count if + * there are no trailers. Trailers are searched only in the lines from + * index (count - 1) down to index 0. + */ +static int find_trailer_start(struct strbuf **lines, int count) +{ + int start, only_spaces = 1; + + /* + * Get the start of the trailers by looking starting from the end + * for a line with only spaces before lines with one separator. + */ + for (start = count - 1; start >= 0; start--) { + if (lines[start]->buf[0] == comment_line_char) + continue; + if (contains_only_spaces(lines[start]->buf)) { + if (only_spaces) + continue; + return start + 1; + } + if (strcspn(lines[start]->buf, separators) < lines[start]->len) { + if (only_spaces) + only_spaces = 0; + continue; + } + return count; + } + + return only_spaces ? count : 0; +} + +static int has_blank_line_before(struct strbuf **lines, int start) +{ + for (;start >= 0; start--) { + if (lines[start]->buf[0] == comment_line_char) + continue; + return contains_only_spaces(lines[start]->buf); + } + return 0; +} + +static void print_lines(struct strbuf **lines, int start, int end) +{ + int i; + for (i = start; lines[i] && i < end; i++) + printf("%s", lines[i]->buf); +} + +static int process_input_file(struct strbuf **lines, + struct trailer_item **in_tok_first, + struct trailer_item **in_tok_last) +{ + int count = 0; + int patch_start, trailer_start, i; + + /* Get the line count */ + while (lines[count]) + count++; + + patch_start = find_patch_start(lines, count); + trailer_start = find_trailer_start(lines, patch_start); + + /* Print lines before the trailers as is */ + print_lines(lines, 0, trailer_start); + + if (!has_blank_line_before(lines, trailer_start - 1)) + printf("\n"); + + /* Parse trailer lines */ + for (i = trailer_start; i < patch_start; i++) { + struct trailer_item *new = create_trailer_item(lines[i]->buf); + add_trailer_item(in_tok_first, in_tok_last, new); + } + + return patch_start; +} + +static void free_all(struct trailer_item **first) +{ + while (*first) { + struct trailer_item *item = remove_first(first); + free_trailer_item(item); + } +} + +void process_trailers(const char *file, 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; + struct strbuf **lines; + int patch_start; + + /* Default config must be setup first */ + git_config(git_trailer_default_config, NULL); + git_config(git_trailer_config, NULL); + + lines = read_input_file(file); + + /* Print the lines before the trailers */ + patch_start = process_input_file(lines, &in_tok_first, &in_tok_last); + + arg_tok_first = process_command_line_args(trailers); + + process_trailers_lists(&in_tok_first, &in_tok_last, &arg_tok_first); + + print_all(in_tok_first, trim_empty); + + free_all(&in_tok_first); + + /* Print the lines after the trailers as is */ + print_lines(lines, patch_start, INT_MAX); + + strbuf_list_free(lines); +} |