fprintf(outfile, "%s%c %s\n", tok, separators[0], val);
}
-static void print_all(FILE *outfile, struct list_head *head, int trim_empty)
+static void print_all(FILE *outfile, struct list_head *head,
+ const struct process_trailer_options *opts)
{
struct list_head *pos;
struct trailer_item *item;
list_for_each(pos, head) {
item = list_entry(pos, struct trailer_item, list);
- if (!trim_empty || strlen(item->value) > 0)
+ if ((!opts->trim_empty || strlen(item->value) > 0) &&
+ (!opts->only_trailers || item->token))
print_tok_val(outfile, item->token, item->value);
}
}
else
free_arg_item(arg_tok);
break;
+ default:
+ die("BUG: trailer.c: unhandled value %d",
+ arg_tok->conf.if_exists);
}
}
list_add_tail(&to_add->list, head);
else
list_add(&to_add->list, head);
+ break;
+ default:
+ die("BUG: trailer.c: unhandled value %d",
+ arg_tok->conf.if_missing);
}
}
int trailer_set_where(enum trailer_where *item, const char *value)
{
- if (!strcasecmp("after", value))
+ if (!value)
+ *item = WHERE_DEFAULT;
+ else if (!strcasecmp("after", value))
*item = WHERE_AFTER;
else if (!strcasecmp("before", value))
*item = WHERE_BEFORE;
int trailer_set_if_exists(enum trailer_if_exists *item, const char *value)
{
- if (!strcasecmp("addIfDifferent", value))
+ if (!value)
+ *item = EXISTS_DEFAULT;
+ else if (!strcasecmp("addIfDifferent", value))
*item = EXISTS_ADD_IF_DIFFERENT;
else if (!strcasecmp("addIfDifferentNeighbor", value))
*item = EXISTS_ADD_IF_DIFFERENT_NEIGHBOR;
int trailer_set_if_missing(enum trailer_if_missing *item, const char *value)
{
- if (!strcasecmp("doNothing", value))
+ if (!value)
+ *item = MISSING_DEFAULT;
+ else if (!strcasecmp("doNothing", value))
*item = MISSING_DO_NOTHING;
else if (!strcasecmp("add", value))
*item = MISSING_ADD;
}
static void add_arg_item(struct list_head *arg_head, char *tok, char *val,
- const struct conf_info *conf)
+ const struct conf_info *conf,
+ const struct new_trailer_item *new_trailer_item)
{
struct arg_item *new = xcalloc(sizeof(*new), 1);
new->token = tok;
new->value = val;
duplicate_conf(&new->conf, conf);
+ if (new_trailer_item) {
+ if (new_trailer_item->where != WHERE_DEFAULT)
+ new->conf.where = new_trailer_item->where;
+ if (new_trailer_item->if_exists != EXISTS_DEFAULT)
+ new->conf.if_exists = new_trailer_item->if_exists;
+ if (new_trailer_item->if_missing != MISSING_DEFAULT)
+ new->conf.if_missing = new_trailer_item->if_missing;
+ }
list_add_tail(&new->list, arg_head);
}
static void process_command_line_args(struct list_head *arg_head,
- struct string_list *trailers)
+ struct list_head *new_trailer_head)
{
- struct string_list_item *tr;
struct arg_item *item;
struct strbuf tok = STRBUF_INIT;
struct strbuf val = STRBUF_INIT;
add_arg_item(arg_head,
xstrdup(token_from_item(item, NULL)),
xstrdup(""),
- &item->conf);
+ &item->conf, NULL);
}
/* 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);
+ list_for_each(pos, new_trailer_head) {
+ struct new_trailer_item *tr =
+ list_entry(pos, struct new_trailer_item, list);
+ int separator_pos = find_separator(tr->text, cl_separators);
+
if (separator_pos == 0) {
struct strbuf sb = STRBUF_INIT;
- strbuf_addstr(&sb, tr->string);
+ strbuf_addstr(&sb, tr->text);
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,
+ parse_trailer(&tok, &val, &conf, tr->text,
separator_pos);
add_arg_item(arg_head,
strbuf_detach(&tok, NULL),
strbuf_detach(&val, NULL),
- conf);
+ conf, tr);
}
}
return is_blank_line(buf + ll);
}
+static void unfold_value(struct strbuf *val)
+{
+ struct strbuf out = STRBUF_INIT;
+ size_t i;
+
+ strbuf_grow(&out, val->len);
+ i = 0;
+ while (i < val->len) {
+ char c = val->buf[i++];
+ if (c == '\n') {
+ /* Collapse continuation down to a single space. */
+ while (i < val->len && isspace(val->buf[i]))
+ i++;
+ strbuf_addch(&out, ' ');
+ } else {
+ strbuf_addch(&out, c);
+ }
+ }
+
+ /* Empty lines may have left us with whitespace cruft at the edges */
+ strbuf_trim(&out);
+
+ /* output goes back to val as if we modified it in-place */
+ strbuf_swap(&out, val);
+ strbuf_release(&out);
+}
+
static int process_input_file(FILE *outfile,
const char *str,
- struct list_head *head)
+ struct list_head *head,
+ const struct process_trailer_options *opts)
{
struct trailer_info info;
struct strbuf tok = STRBUF_INIT;
trailer_info_get(&info, str);
/* Print lines before the trailers as is */
- fwrite(str, 1, info.trailer_start - str, outfile);
+ if (!opts->only_trailers)
+ fwrite(str, 1, info.trailer_start - str, outfile);
- if (!info.blank_line_before_trailer)
+ if (!opts->only_trailers && !info.blank_line_before_trailer)
fprintf(outfile, "\n");
for (i = 0; i < info.trailer_nr; i++) {
if (separator_pos >= 1) {
parse_trailer(&tok, &val, NULL, trailer,
separator_pos);
+ if (opts->unfold)
+ unfold_value(&val);
add_trailer_item(head,
strbuf_detach(&tok, NULL),
strbuf_detach(&val, NULL));
- } else {
+ } else if (!opts->only_trailers) {
strbuf_addstr(&val, trailer);
strbuf_strip_suffix(&val, "\n");
add_trailer_item(head,
return outfile;
}
-void process_trailers(const char *file, int in_place, int trim_empty, struct string_list *trailers)
+void process_trailers(const char *file,
+ const struct process_trailer_options *opts,
+ struct list_head *new_trailer_head)
{
LIST_HEAD(head);
- LIST_HEAD(arg_head);
struct strbuf sb = STRBUF_INIT;
int trailer_end;
FILE *outfile = stdout;
read_input_file(&sb, file);
- if (in_place)
+ if (opts->in_place)
outfile = create_in_place_tempfile(file);
/* Print the lines before the trailers */
- trailer_end = process_input_file(outfile, sb.buf, &head);
-
- process_command_line_args(&arg_head, trailers);
+ trailer_end = process_input_file(outfile, sb.buf, &head, opts);
- process_trailers_lists(&head, &arg_head);
+ if (!opts->only_input) {
+ LIST_HEAD(arg_head);
+ process_command_line_args(&arg_head, new_trailer_head);
+ process_trailers_lists(&head, &arg_head);
+ }
- print_all(outfile, &head, trim_empty);
+ print_all(outfile, &head, opts);
free_all(&head);
/* Print the lines after the trailers as is */
- fwrite(sb.buf + trailer_end, 1, sb.len - trailer_end, outfile);
+ if (!opts->only_trailers)
+ fwrite(sb.buf + trailer_end, 1, sb.len - trailer_end, outfile);
- if (in_place)
+ if (opts->in_place)
if (rename_tempfile(&trailers_tempfile, file))
die_errno(_("could not rename temporary file to %s"), file);
free(info->trailers[i]);
free(info->trailers);
}
+
+static void format_trailer_info(struct strbuf *out,
+ const struct trailer_info *info,
+ const struct process_trailer_options *opts)
+{
+ int i;
+
+ /* If we want the whole block untouched, we can take the fast path. */
+ if (!opts->only_trailers && !opts->unfold) {
+ strbuf_add(out, info->trailer_start,
+ info->trailer_end - info->trailer_start);
+ return;
+ }
+
+ for (i = 0; i < info->trailer_nr; i++) {
+ char *trailer = info->trailers[i];
+ int separator_pos = find_separator(trailer, separators);
+
+ if (separator_pos >= 1) {
+ struct strbuf tok = STRBUF_INIT;
+ struct strbuf val = STRBUF_INIT;
+
+ parse_trailer(&tok, &val, NULL, trailer, separator_pos);
+ if (opts->unfold)
+ unfold_value(&val);
+
+ strbuf_addf(out, "%s: %s\n", tok.buf, val.buf);
+ strbuf_release(&tok);
+ strbuf_release(&val);
+
+ } else if (!opts->only_trailers) {
+ strbuf_addstr(out, trailer);
+ }
+ }
+
+}
+
+void format_trailers_from_commit(struct strbuf *out, const char *msg,
+ const struct process_trailer_options *opts)
+{
+ struct trailer_info info;
+
+ trailer_info_get(&info, msg);
+ format_trailer_info(out, &info, opts);
+ trailer_info_release(&info);
+}
OSDN Git Service
