mirror of
https://github.com/git/git
synced 2024-08-27 11:39:22 +00:00
![Lars Hjemli](/assets/img/avatar_default.png)
Commit de435ac0
changed the behavior of --decorate from printing the
full ref (e.g., "refs/heads/master") to a shorter, more human-readable
version (e.g., just "master"). While this is nice for human readers,
external tools using the output from "git log" may prefer the full
version.
This patch introduces an extension to --decorate to allow the caller to
specify either the short or the full versions.
Signed-off-by: Lars Hjemli <hjemli@gmail.com>
Acked-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
980 lines
24 KiB
C
980 lines
24 KiB
C
#include "cache.h"
|
|
#include "commit.h"
|
|
#include "utf8.h"
|
|
#include "diff.h"
|
|
#include "revision.h"
|
|
#include "string-list.h"
|
|
#include "mailmap.h"
|
|
#include "log-tree.h"
|
|
#include "color.h"
|
|
|
|
static char *user_format;
|
|
|
|
static void save_user_format(struct rev_info *rev, const char *cp, int is_tformat)
|
|
{
|
|
free(user_format);
|
|
user_format = xstrdup(cp);
|
|
if (is_tformat)
|
|
rev->use_terminator = 1;
|
|
rev->commit_format = CMIT_FMT_USERFORMAT;
|
|
}
|
|
|
|
void get_commit_format(const char *arg, struct rev_info *rev)
|
|
{
|
|
int i;
|
|
static struct cmt_fmt_map {
|
|
const char *n;
|
|
size_t cmp_len;
|
|
enum cmit_fmt v;
|
|
} cmt_fmts[] = {
|
|
{ "raw", 1, CMIT_FMT_RAW },
|
|
{ "medium", 1, CMIT_FMT_MEDIUM },
|
|
{ "short", 1, CMIT_FMT_SHORT },
|
|
{ "email", 1, CMIT_FMT_EMAIL },
|
|
{ "full", 5, CMIT_FMT_FULL },
|
|
{ "fuller", 5, CMIT_FMT_FULLER },
|
|
{ "oneline", 1, CMIT_FMT_ONELINE },
|
|
};
|
|
|
|
rev->use_terminator = 0;
|
|
if (!arg || !*arg) {
|
|
rev->commit_format = CMIT_FMT_DEFAULT;
|
|
return;
|
|
}
|
|
if (!prefixcmp(arg, "format:") || !prefixcmp(arg, "tformat:")) {
|
|
save_user_format(rev, strchr(arg, ':') + 1, arg[0] == 't');
|
|
return;
|
|
}
|
|
for (i = 0; i < ARRAY_SIZE(cmt_fmts); i++) {
|
|
if (!strncmp(arg, cmt_fmts[i].n, cmt_fmts[i].cmp_len) &&
|
|
!strncmp(arg, cmt_fmts[i].n, strlen(arg))) {
|
|
if (cmt_fmts[i].v == CMIT_FMT_ONELINE)
|
|
rev->use_terminator = 1;
|
|
rev->commit_format = cmt_fmts[i].v;
|
|
return;
|
|
}
|
|
}
|
|
if (strchr(arg, '%')) {
|
|
save_user_format(rev, arg, 1);
|
|
return;
|
|
}
|
|
|
|
die("invalid --pretty format: %s", arg);
|
|
}
|
|
|
|
/*
|
|
* Generic support for pretty-printing the header
|
|
*/
|
|
static int get_one_line(const char *msg)
|
|
{
|
|
int ret = 0;
|
|
|
|
for (;;) {
|
|
char c = *msg++;
|
|
if (!c)
|
|
break;
|
|
ret++;
|
|
if (c == '\n')
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* High bit set, or ISO-2022-INT */
|
|
int non_ascii(int ch)
|
|
{
|
|
return !isascii(ch) || ch == '\033';
|
|
}
|
|
|
|
int has_non_ascii(const char *s)
|
|
{
|
|
int ch;
|
|
if (!s)
|
|
return 0;
|
|
while ((ch = *s++) != '\0') {
|
|
if (non_ascii(ch))
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int is_rfc2047_special(char ch)
|
|
{
|
|
return (non_ascii(ch) || (ch == '=') || (ch == '?') || (ch == '_'));
|
|
}
|
|
|
|
static void add_rfc2047(struct strbuf *sb, const char *line, int len,
|
|
const char *encoding)
|
|
{
|
|
int i, last;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
int ch = line[i];
|
|
if (non_ascii(ch))
|
|
goto needquote;
|
|
if ((i + 1 < len) && (ch == '=' && line[i+1] == '?'))
|
|
goto needquote;
|
|
}
|
|
strbuf_add(sb, line, len);
|
|
return;
|
|
|
|
needquote:
|
|
strbuf_grow(sb, len * 3 + strlen(encoding) + 100);
|
|
strbuf_addf(sb, "=?%s?q?", encoding);
|
|
for (i = last = 0; i < len; i++) {
|
|
unsigned ch = line[i] & 0xFF;
|
|
/*
|
|
* We encode ' ' using '=20' even though rfc2047
|
|
* allows using '_' for readability. Unfortunately,
|
|
* many programs do not understand this and just
|
|
* leave the underscore in place.
|
|
*/
|
|
if (is_rfc2047_special(ch) || ch == ' ') {
|
|
strbuf_add(sb, line + last, i - last);
|
|
strbuf_addf(sb, "=%02X", ch);
|
|
last = i + 1;
|
|
}
|
|
}
|
|
strbuf_add(sb, line + last, len - last);
|
|
strbuf_addstr(sb, "?=");
|
|
}
|
|
|
|
void pp_user_info(const char *what, enum cmit_fmt fmt, struct strbuf *sb,
|
|
const char *line, enum date_mode dmode,
|
|
const char *encoding)
|
|
{
|
|
char *date;
|
|
int namelen;
|
|
unsigned long time;
|
|
int tz;
|
|
|
|
if (fmt == CMIT_FMT_ONELINE)
|
|
return;
|
|
date = strchr(line, '>');
|
|
if (!date)
|
|
return;
|
|
namelen = ++date - line;
|
|
time = strtoul(date, &date, 10);
|
|
tz = strtol(date, NULL, 10);
|
|
|
|
if (fmt == CMIT_FMT_EMAIL) {
|
|
char *name_tail = strchr(line, '<');
|
|
int display_name_length;
|
|
if (!name_tail)
|
|
return;
|
|
while (line < name_tail && isspace(name_tail[-1]))
|
|
name_tail--;
|
|
display_name_length = name_tail - line;
|
|
strbuf_addstr(sb, "From: ");
|
|
add_rfc2047(sb, line, display_name_length, encoding);
|
|
strbuf_add(sb, name_tail, namelen - display_name_length);
|
|
strbuf_addch(sb, '\n');
|
|
} else {
|
|
strbuf_addf(sb, "%s: %.*s%.*s\n", what,
|
|
(fmt == CMIT_FMT_FULLER) ? 4 : 0,
|
|
" ", namelen, line);
|
|
}
|
|
switch (fmt) {
|
|
case CMIT_FMT_MEDIUM:
|
|
strbuf_addf(sb, "Date: %s\n", show_date(time, tz, dmode));
|
|
break;
|
|
case CMIT_FMT_EMAIL:
|
|
strbuf_addf(sb, "Date: %s\n", show_date(time, tz, DATE_RFC2822));
|
|
break;
|
|
case CMIT_FMT_FULLER:
|
|
strbuf_addf(sb, "%sDate: %s\n", what, show_date(time, tz, dmode));
|
|
break;
|
|
default:
|
|
/* notin' */
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int is_empty_line(const char *line, int *len_p)
|
|
{
|
|
int len = *len_p;
|
|
while (len && isspace(line[len-1]))
|
|
len--;
|
|
*len_p = len;
|
|
return !len;
|
|
}
|
|
|
|
static const char *skip_empty_lines(const char *msg)
|
|
{
|
|
for (;;) {
|
|
int linelen = get_one_line(msg);
|
|
int ll = linelen;
|
|
if (!linelen)
|
|
break;
|
|
if (!is_empty_line(msg, &ll))
|
|
break;
|
|
msg += linelen;
|
|
}
|
|
return msg;
|
|
}
|
|
|
|
static void add_merge_info(enum cmit_fmt fmt, struct strbuf *sb,
|
|
const struct commit *commit, int abbrev)
|
|
{
|
|
struct commit_list *parent = commit->parents;
|
|
|
|
if ((fmt == CMIT_FMT_ONELINE) || (fmt == CMIT_FMT_EMAIL) ||
|
|
!parent || !parent->next)
|
|
return;
|
|
|
|
strbuf_addstr(sb, "Merge:");
|
|
|
|
while (parent) {
|
|
struct commit *p = parent->item;
|
|
const char *hex = NULL;
|
|
if (abbrev)
|
|
hex = find_unique_abbrev(p->object.sha1, abbrev);
|
|
if (!hex)
|
|
hex = sha1_to_hex(p->object.sha1);
|
|
parent = parent->next;
|
|
|
|
strbuf_addf(sb, " %s", hex);
|
|
}
|
|
strbuf_addch(sb, '\n');
|
|
}
|
|
|
|
static char *get_header(const struct commit *commit, const char *key)
|
|
{
|
|
int key_len = strlen(key);
|
|
const char *line = commit->buffer;
|
|
|
|
for (;;) {
|
|
const char *eol = strchr(line, '\n'), *next;
|
|
|
|
if (line == eol)
|
|
return NULL;
|
|
if (!eol) {
|
|
eol = line + strlen(line);
|
|
next = NULL;
|
|
} else
|
|
next = eol + 1;
|
|
if (eol - line > key_len &&
|
|
!strncmp(line, key, key_len) &&
|
|
line[key_len] == ' ') {
|
|
return xmemdupz(line + key_len + 1, eol - line - key_len - 1);
|
|
}
|
|
line = next;
|
|
}
|
|
}
|
|
|
|
static char *replace_encoding_header(char *buf, const char *encoding)
|
|
{
|
|
struct strbuf tmp = STRBUF_INIT;
|
|
size_t start, len;
|
|
char *cp = buf;
|
|
|
|
/* guess if there is an encoding header before a \n\n */
|
|
while (strncmp(cp, "encoding ", strlen("encoding "))) {
|
|
cp = strchr(cp, '\n');
|
|
if (!cp || *++cp == '\n')
|
|
return buf;
|
|
}
|
|
start = cp - buf;
|
|
cp = strchr(cp, '\n');
|
|
if (!cp)
|
|
return buf; /* should not happen but be defensive */
|
|
len = cp + 1 - (buf + start);
|
|
|
|
strbuf_attach(&tmp, buf, strlen(buf), strlen(buf) + 1);
|
|
if (is_encoding_utf8(encoding)) {
|
|
/* we have re-coded to UTF-8; drop the header */
|
|
strbuf_remove(&tmp, start, len);
|
|
} else {
|
|
/* just replaces XXXX in 'encoding XXXX\n' */
|
|
strbuf_splice(&tmp, start + strlen("encoding "),
|
|
len - strlen("encoding \n"),
|
|
encoding, strlen(encoding));
|
|
}
|
|
return strbuf_detach(&tmp, NULL);
|
|
}
|
|
|
|
static char *logmsg_reencode(const struct commit *commit,
|
|
const char *output_encoding)
|
|
{
|
|
static const char *utf8 = "UTF-8";
|
|
const char *use_encoding;
|
|
char *encoding;
|
|
char *out;
|
|
|
|
if (!*output_encoding)
|
|
return NULL;
|
|
encoding = get_header(commit, "encoding");
|
|
use_encoding = encoding ? encoding : utf8;
|
|
if (!strcmp(use_encoding, output_encoding))
|
|
if (encoding) /* we'll strip encoding header later */
|
|
out = xstrdup(commit->buffer);
|
|
else
|
|
return NULL; /* nothing to do */
|
|
else
|
|
out = reencode_string(commit->buffer,
|
|
output_encoding, use_encoding);
|
|
if (out)
|
|
out = replace_encoding_header(out, output_encoding);
|
|
|
|
free(encoding);
|
|
return out;
|
|
}
|
|
|
|
static int mailmap_name(char *email, int email_len, char *name, int name_len)
|
|
{
|
|
static struct string_list *mail_map;
|
|
if (!mail_map) {
|
|
mail_map = xcalloc(1, sizeof(*mail_map));
|
|
read_mailmap(mail_map, NULL);
|
|
}
|
|
return mail_map->nr && map_user(mail_map, email, email_len, name, name_len);
|
|
}
|
|
|
|
static size_t format_person_part(struct strbuf *sb, char part,
|
|
const char *msg, int len, enum date_mode dmode)
|
|
{
|
|
/* currently all placeholders have same length */
|
|
const int placeholder_len = 2;
|
|
int start, end, tz = 0;
|
|
unsigned long date = 0;
|
|
char *ep;
|
|
const char *name_start, *name_end, *mail_start, *mail_end, *msg_end = msg+len;
|
|
char person_name[1024];
|
|
char person_mail[1024];
|
|
|
|
/* advance 'end' to point to email start delimiter */
|
|
for (end = 0; end < len && msg[end] != '<'; end++)
|
|
; /* do nothing */
|
|
|
|
/*
|
|
* When end points at the '<' that we found, it should have
|
|
* matching '>' later, which means 'end' must be strictly
|
|
* below len - 1.
|
|
*/
|
|
if (end >= len - 2)
|
|
goto skip;
|
|
|
|
/* Seek for both name and email part */
|
|
name_start = msg;
|
|
name_end = msg+end;
|
|
while (name_end > name_start && isspace(*(name_end-1)))
|
|
name_end--;
|
|
mail_start = msg+end+1;
|
|
mail_end = mail_start;
|
|
while (mail_end < msg_end && *mail_end != '>')
|
|
mail_end++;
|
|
if (mail_end == msg_end)
|
|
goto skip;
|
|
end = mail_end-msg;
|
|
|
|
if (part == 'N' || part == 'E') { /* mailmap lookup */
|
|
strlcpy(person_name, name_start, name_end-name_start+1);
|
|
strlcpy(person_mail, mail_start, mail_end-mail_start+1);
|
|
mailmap_name(person_mail, sizeof(person_mail), person_name, sizeof(person_name));
|
|
name_start = person_name;
|
|
name_end = name_start + strlen(person_name);
|
|
mail_start = person_mail;
|
|
mail_end = mail_start + strlen(person_mail);
|
|
}
|
|
if (part == 'n' || part == 'N') { /* name */
|
|
strbuf_add(sb, name_start, name_end-name_start);
|
|
return placeholder_len;
|
|
}
|
|
if (part == 'e' || part == 'E') { /* email */
|
|
strbuf_add(sb, mail_start, mail_end-mail_start);
|
|
return placeholder_len;
|
|
}
|
|
|
|
/* advance 'start' to point to date start delimiter */
|
|
for (start = end + 1; start < len && isspace(msg[start]); start++)
|
|
; /* do nothing */
|
|
if (start >= len)
|
|
goto skip;
|
|
date = strtoul(msg + start, &ep, 10);
|
|
if (msg + start == ep)
|
|
goto skip;
|
|
|
|
if (part == 't') { /* date, UNIX timestamp */
|
|
strbuf_add(sb, msg + start, ep - (msg + start));
|
|
return placeholder_len;
|
|
}
|
|
|
|
/* parse tz */
|
|
for (start = ep - msg + 1; start < len && isspace(msg[start]); start++)
|
|
; /* do nothing */
|
|
if (start + 1 < len) {
|
|
tz = strtoul(msg + start + 1, NULL, 10);
|
|
if (msg[start] == '-')
|
|
tz = -tz;
|
|
}
|
|
|
|
switch (part) {
|
|
case 'd': /* date */
|
|
strbuf_addstr(sb, show_date(date, tz, dmode));
|
|
return placeholder_len;
|
|
case 'D': /* date, RFC2822 style */
|
|
strbuf_addstr(sb, show_date(date, tz, DATE_RFC2822));
|
|
return placeholder_len;
|
|
case 'r': /* date, relative */
|
|
strbuf_addstr(sb, show_date(date, tz, DATE_RELATIVE));
|
|
return placeholder_len;
|
|
case 'i': /* date, ISO 8601 */
|
|
strbuf_addstr(sb, show_date(date, tz, DATE_ISO8601));
|
|
return placeholder_len;
|
|
}
|
|
|
|
skip:
|
|
/*
|
|
* bogus commit, 'sb' cannot be updated, but we still need to
|
|
* compute a valid return value.
|
|
*/
|
|
if (part == 'n' || part == 'e' || part == 't' || part == 'd'
|
|
|| part == 'D' || part == 'r' || part == 'i')
|
|
return placeholder_len;
|
|
|
|
return 0; /* unknown placeholder */
|
|
}
|
|
|
|
struct chunk {
|
|
size_t off;
|
|
size_t len;
|
|
};
|
|
|
|
struct format_commit_context {
|
|
const struct commit *commit;
|
|
enum date_mode dmode;
|
|
unsigned commit_header_parsed:1;
|
|
unsigned commit_message_parsed:1;
|
|
|
|
/* These offsets are relative to the start of the commit message. */
|
|
struct chunk author;
|
|
struct chunk committer;
|
|
struct chunk encoding;
|
|
size_t message_off;
|
|
size_t subject_off;
|
|
size_t body_off;
|
|
|
|
/* The following ones are relative to the result struct strbuf. */
|
|
struct chunk abbrev_commit_hash;
|
|
struct chunk abbrev_tree_hash;
|
|
struct chunk abbrev_parent_hashes;
|
|
};
|
|
|
|
static int add_again(struct strbuf *sb, struct chunk *chunk)
|
|
{
|
|
if (chunk->len) {
|
|
strbuf_adddup(sb, chunk->off, chunk->len);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* We haven't seen this chunk before. Our caller is surely
|
|
* going to add it the hard way now. Remember the most likely
|
|
* start of the to-be-added chunk: the current end of the
|
|
* struct strbuf.
|
|
*/
|
|
chunk->off = sb->len;
|
|
return 0;
|
|
}
|
|
|
|
static void parse_commit_header(struct format_commit_context *context)
|
|
{
|
|
const char *msg = context->commit->buffer;
|
|
int i;
|
|
|
|
for (i = 0; msg[i]; i++) {
|
|
int eol;
|
|
for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
|
|
; /* do nothing */
|
|
|
|
if (i == eol) {
|
|
break;
|
|
} else if (!prefixcmp(msg + i, "author ")) {
|
|
context->author.off = i + 7;
|
|
context->author.len = eol - i - 7;
|
|
} else if (!prefixcmp(msg + i, "committer ")) {
|
|
context->committer.off = i + 10;
|
|
context->committer.len = eol - i - 10;
|
|
} else if (!prefixcmp(msg + i, "encoding ")) {
|
|
context->encoding.off = i + 9;
|
|
context->encoding.len = eol - i - 9;
|
|
}
|
|
i = eol;
|
|
}
|
|
context->message_off = i;
|
|
context->commit_header_parsed = 1;
|
|
}
|
|
|
|
static int istitlechar(char c)
|
|
{
|
|
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
|
|
(c >= '0' && c <= '9') || c == '.' || c == '_';
|
|
}
|
|
|
|
static void format_sanitized_subject(struct strbuf *sb, const char *msg)
|
|
{
|
|
size_t trimlen;
|
|
size_t start_len = sb->len;
|
|
int space = 2;
|
|
|
|
for (; *msg && *msg != '\n'; msg++) {
|
|
if (istitlechar(*msg)) {
|
|
if (space == 1)
|
|
strbuf_addch(sb, '-');
|
|
space = 0;
|
|
strbuf_addch(sb, *msg);
|
|
if (*msg == '.')
|
|
while (*(msg+1) == '.')
|
|
msg++;
|
|
} else
|
|
space |= 1;
|
|
}
|
|
|
|
/* trim any trailing '.' or '-' characters */
|
|
trimlen = 0;
|
|
while (sb->len - trimlen > start_len &&
|
|
(sb->buf[sb->len - 1 - trimlen] == '.'
|
|
|| sb->buf[sb->len - 1 - trimlen] == '-'))
|
|
trimlen++;
|
|
strbuf_remove(sb, sb->len - trimlen, trimlen);
|
|
}
|
|
|
|
const char *format_subject(struct strbuf *sb, const char *msg,
|
|
const char *line_separator)
|
|
{
|
|
int first = 1;
|
|
|
|
for (;;) {
|
|
const char *line = msg;
|
|
int linelen = get_one_line(line);
|
|
|
|
msg += linelen;
|
|
if (!linelen || is_empty_line(line, &linelen))
|
|
break;
|
|
|
|
if (!sb)
|
|
continue;
|
|
strbuf_grow(sb, linelen + 2);
|
|
if (!first)
|
|
strbuf_addstr(sb, line_separator);
|
|
strbuf_add(sb, line, linelen);
|
|
first = 0;
|
|
}
|
|
return msg;
|
|
}
|
|
|
|
static void parse_commit_message(struct format_commit_context *c)
|
|
{
|
|
const char *msg = c->commit->buffer + c->message_off;
|
|
const char *start = c->commit->buffer;
|
|
|
|
msg = skip_empty_lines(msg);
|
|
c->subject_off = msg - start;
|
|
|
|
msg = format_subject(NULL, msg, NULL);
|
|
msg = skip_empty_lines(msg);
|
|
c->body_off = msg - start;
|
|
|
|
c->commit_message_parsed = 1;
|
|
}
|
|
|
|
static void format_decoration(struct strbuf *sb, const struct commit *commit)
|
|
{
|
|
struct name_decoration *d;
|
|
const char *prefix = " (";
|
|
|
|
load_ref_decorations(DECORATE_SHORT_REFS);
|
|
d = lookup_decoration(&name_decoration, &commit->object);
|
|
while (d) {
|
|
strbuf_addstr(sb, prefix);
|
|
prefix = ", ";
|
|
strbuf_addstr(sb, d->name);
|
|
d = d->next;
|
|
}
|
|
if (prefix[0] == ',')
|
|
strbuf_addch(sb, ')');
|
|
}
|
|
|
|
static size_t format_commit_item(struct strbuf *sb, const char *placeholder,
|
|
void *context)
|
|
{
|
|
struct format_commit_context *c = context;
|
|
const struct commit *commit = c->commit;
|
|
const char *msg = commit->buffer;
|
|
struct commit_list *p;
|
|
int h1, h2;
|
|
|
|
/* these are independent of the commit */
|
|
switch (placeholder[0]) {
|
|
case 'C':
|
|
if (placeholder[1] == '(') {
|
|
const char *end = strchr(placeholder + 2, ')');
|
|
char color[COLOR_MAXLEN];
|
|
if (!end)
|
|
return 0;
|
|
color_parse_mem(placeholder + 2,
|
|
end - (placeholder + 2),
|
|
"--pretty format", color);
|
|
strbuf_addstr(sb, color);
|
|
return end - placeholder + 1;
|
|
}
|
|
if (!prefixcmp(placeholder + 1, "red")) {
|
|
strbuf_addstr(sb, GIT_COLOR_RED);
|
|
return 4;
|
|
} else if (!prefixcmp(placeholder + 1, "green")) {
|
|
strbuf_addstr(sb, GIT_COLOR_GREEN);
|
|
return 6;
|
|
} else if (!prefixcmp(placeholder + 1, "blue")) {
|
|
strbuf_addstr(sb, GIT_COLOR_BLUE);
|
|
return 5;
|
|
} else if (!prefixcmp(placeholder + 1, "reset")) {
|
|
strbuf_addstr(sb, GIT_COLOR_RESET);
|
|
return 6;
|
|
} else
|
|
return 0;
|
|
case 'n': /* newline */
|
|
strbuf_addch(sb, '\n');
|
|
return 1;
|
|
case 'x':
|
|
/* %x00 == NUL, %x0a == LF, etc. */
|
|
if (0 <= (h1 = hexval_table[0xff & placeholder[1]]) &&
|
|
h1 <= 16 &&
|
|
0 <= (h2 = hexval_table[0xff & placeholder[2]]) &&
|
|
h2 <= 16) {
|
|
strbuf_addch(sb, (h1<<4)|h2);
|
|
return 3;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
/* these depend on the commit */
|
|
if (!commit->object.parsed)
|
|
parse_object(commit->object.sha1);
|
|
|
|
switch (placeholder[0]) {
|
|
case 'H': /* commit hash */
|
|
strbuf_addstr(sb, sha1_to_hex(commit->object.sha1));
|
|
return 1;
|
|
case 'h': /* abbreviated commit hash */
|
|
if (add_again(sb, &c->abbrev_commit_hash))
|
|
return 1;
|
|
strbuf_addstr(sb, find_unique_abbrev(commit->object.sha1,
|
|
DEFAULT_ABBREV));
|
|
c->abbrev_commit_hash.len = sb->len - c->abbrev_commit_hash.off;
|
|
return 1;
|
|
case 'T': /* tree hash */
|
|
strbuf_addstr(sb, sha1_to_hex(commit->tree->object.sha1));
|
|
return 1;
|
|
case 't': /* abbreviated tree hash */
|
|
if (add_again(sb, &c->abbrev_tree_hash))
|
|
return 1;
|
|
strbuf_addstr(sb, find_unique_abbrev(commit->tree->object.sha1,
|
|
DEFAULT_ABBREV));
|
|
c->abbrev_tree_hash.len = sb->len - c->abbrev_tree_hash.off;
|
|
return 1;
|
|
case 'P': /* parent hashes */
|
|
for (p = commit->parents; p; p = p->next) {
|
|
if (p != commit->parents)
|
|
strbuf_addch(sb, ' ');
|
|
strbuf_addstr(sb, sha1_to_hex(p->item->object.sha1));
|
|
}
|
|
return 1;
|
|
case 'p': /* abbreviated parent hashes */
|
|
if (add_again(sb, &c->abbrev_parent_hashes))
|
|
return 1;
|
|
for (p = commit->parents; p; p = p->next) {
|
|
if (p != commit->parents)
|
|
strbuf_addch(sb, ' ');
|
|
strbuf_addstr(sb, find_unique_abbrev(
|
|
p->item->object.sha1, DEFAULT_ABBREV));
|
|
}
|
|
c->abbrev_parent_hashes.len = sb->len -
|
|
c->abbrev_parent_hashes.off;
|
|
return 1;
|
|
case 'm': /* left/right/bottom */
|
|
strbuf_addch(sb, (commit->object.flags & BOUNDARY)
|
|
? '-'
|
|
: (commit->object.flags & SYMMETRIC_LEFT)
|
|
? '<'
|
|
: '>');
|
|
return 1;
|
|
case 'd':
|
|
format_decoration(sb, commit);
|
|
return 1;
|
|
}
|
|
|
|
/* For the rest we have to parse the commit header. */
|
|
if (!c->commit_header_parsed)
|
|
parse_commit_header(c);
|
|
|
|
switch (placeholder[0]) {
|
|
case 'a': /* author ... */
|
|
return format_person_part(sb, placeholder[1],
|
|
msg + c->author.off, c->author.len,
|
|
c->dmode);
|
|
case 'c': /* committer ... */
|
|
return format_person_part(sb, placeholder[1],
|
|
msg + c->committer.off, c->committer.len,
|
|
c->dmode);
|
|
case 'e': /* encoding */
|
|
strbuf_add(sb, msg + c->encoding.off, c->encoding.len);
|
|
return 1;
|
|
}
|
|
|
|
/* Now we need to parse the commit message. */
|
|
if (!c->commit_message_parsed)
|
|
parse_commit_message(c);
|
|
|
|
switch (placeholder[0]) {
|
|
case 's': /* subject */
|
|
format_subject(sb, msg + c->subject_off, " ");
|
|
return 1;
|
|
case 'f': /* sanitized subject */
|
|
format_sanitized_subject(sb, msg + c->subject_off);
|
|
return 1;
|
|
case 'b': /* body */
|
|
strbuf_addstr(sb, msg + c->body_off);
|
|
return 1;
|
|
}
|
|
return 0; /* unknown placeholder */
|
|
}
|
|
|
|
void format_commit_message(const struct commit *commit,
|
|
const void *format, struct strbuf *sb,
|
|
enum date_mode dmode)
|
|
{
|
|
struct format_commit_context context;
|
|
|
|
memset(&context, 0, sizeof(context));
|
|
context.commit = commit;
|
|
context.dmode = dmode;
|
|
strbuf_expand(sb, format, format_commit_item, &context);
|
|
}
|
|
|
|
static void pp_header(enum cmit_fmt fmt,
|
|
int abbrev,
|
|
enum date_mode dmode,
|
|
const char *encoding,
|
|
const struct commit *commit,
|
|
const char **msg_p,
|
|
struct strbuf *sb)
|
|
{
|
|
int parents_shown = 0;
|
|
|
|
for (;;) {
|
|
const char *line = *msg_p;
|
|
int linelen = get_one_line(*msg_p);
|
|
|
|
if (!linelen)
|
|
return;
|
|
*msg_p += linelen;
|
|
|
|
if (linelen == 1)
|
|
/* End of header */
|
|
return;
|
|
|
|
if (fmt == CMIT_FMT_RAW) {
|
|
strbuf_add(sb, line, linelen);
|
|
continue;
|
|
}
|
|
|
|
if (!memcmp(line, "parent ", 7)) {
|
|
if (linelen != 48)
|
|
die("bad parent line in commit");
|
|
continue;
|
|
}
|
|
|
|
if (!parents_shown) {
|
|
struct commit_list *parent;
|
|
int num;
|
|
for (parent = commit->parents, num = 0;
|
|
parent;
|
|
parent = parent->next, num++)
|
|
;
|
|
/* with enough slop */
|
|
strbuf_grow(sb, num * 50 + 20);
|
|
add_merge_info(fmt, sb, commit, abbrev);
|
|
parents_shown = 1;
|
|
}
|
|
|
|
/*
|
|
* MEDIUM == DEFAULT shows only author with dates.
|
|
* FULL shows both authors but not dates.
|
|
* FULLER shows both authors and dates.
|
|
*/
|
|
if (!memcmp(line, "author ", 7)) {
|
|
strbuf_grow(sb, linelen + 80);
|
|
pp_user_info("Author", fmt, sb, line + 7, dmode, encoding);
|
|
}
|
|
if (!memcmp(line, "committer ", 10) &&
|
|
(fmt == CMIT_FMT_FULL || fmt == CMIT_FMT_FULLER)) {
|
|
strbuf_grow(sb, linelen + 80);
|
|
pp_user_info("Commit", fmt, sb, line + 10, dmode, encoding);
|
|
}
|
|
}
|
|
}
|
|
|
|
void pp_title_line(enum cmit_fmt fmt,
|
|
const char **msg_p,
|
|
struct strbuf *sb,
|
|
const char *subject,
|
|
const char *after_subject,
|
|
const char *encoding,
|
|
int need_8bit_cte)
|
|
{
|
|
const char *line_separator = (fmt == CMIT_FMT_EMAIL) ? "\n " : " ";
|
|
struct strbuf title;
|
|
|
|
strbuf_init(&title, 80);
|
|
*msg_p = format_subject(&title, *msg_p, line_separator);
|
|
|
|
strbuf_grow(sb, title.len + 1024);
|
|
if (subject) {
|
|
strbuf_addstr(sb, subject);
|
|
add_rfc2047(sb, title.buf, title.len, encoding);
|
|
} else {
|
|
strbuf_addbuf(sb, &title);
|
|
}
|
|
strbuf_addch(sb, '\n');
|
|
|
|
if (need_8bit_cte > 0) {
|
|
const char *header_fmt =
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: text/plain; charset=%s\n"
|
|
"Content-Transfer-Encoding: 8bit\n";
|
|
strbuf_addf(sb, header_fmt, encoding);
|
|
}
|
|
if (after_subject) {
|
|
strbuf_addstr(sb, after_subject);
|
|
}
|
|
if (fmt == CMIT_FMT_EMAIL) {
|
|
strbuf_addch(sb, '\n');
|
|
}
|
|
strbuf_release(&title);
|
|
}
|
|
|
|
void pp_remainder(enum cmit_fmt fmt,
|
|
const char **msg_p,
|
|
struct strbuf *sb,
|
|
int indent)
|
|
{
|
|
int first = 1;
|
|
for (;;) {
|
|
const char *line = *msg_p;
|
|
int linelen = get_one_line(line);
|
|
*msg_p += linelen;
|
|
|
|
if (!linelen)
|
|
break;
|
|
|
|
if (is_empty_line(line, &linelen)) {
|
|
if (first)
|
|
continue;
|
|
if (fmt == CMIT_FMT_SHORT)
|
|
break;
|
|
}
|
|
first = 0;
|
|
|
|
strbuf_grow(sb, linelen + indent + 20);
|
|
if (indent) {
|
|
memset(sb->buf + sb->len, ' ', indent);
|
|
strbuf_setlen(sb, sb->len + indent);
|
|
}
|
|
strbuf_add(sb, line, linelen);
|
|
strbuf_addch(sb, '\n');
|
|
}
|
|
}
|
|
|
|
char *reencode_commit_message(const struct commit *commit, const char **encoding_p)
|
|
{
|
|
const char *encoding;
|
|
|
|
encoding = (git_log_output_encoding
|
|
? git_log_output_encoding
|
|
: git_commit_encoding);
|
|
if (!encoding)
|
|
encoding = "UTF-8";
|
|
if (encoding_p)
|
|
*encoding_p = encoding;
|
|
return logmsg_reencode(commit, encoding);
|
|
}
|
|
|
|
void pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit,
|
|
struct strbuf *sb, int abbrev,
|
|
const char *subject, const char *after_subject,
|
|
enum date_mode dmode, int need_8bit_cte)
|
|
{
|
|
unsigned long beginning_of_body;
|
|
int indent = 4;
|
|
const char *msg = commit->buffer;
|
|
char *reencoded;
|
|
const char *encoding;
|
|
|
|
if (fmt == CMIT_FMT_USERFORMAT) {
|
|
format_commit_message(commit, user_format, sb, dmode);
|
|
return;
|
|
}
|
|
|
|
reencoded = reencode_commit_message(commit, &encoding);
|
|
if (reencoded) {
|
|
msg = reencoded;
|
|
}
|
|
|
|
if (fmt == CMIT_FMT_ONELINE || fmt == CMIT_FMT_EMAIL)
|
|
indent = 0;
|
|
|
|
/*
|
|
* We need to check and emit Content-type: to mark it
|
|
* as 8-bit if we haven't done so.
|
|
*/
|
|
if (fmt == CMIT_FMT_EMAIL && need_8bit_cte == 0) {
|
|
int i, ch, in_body;
|
|
|
|
for (in_body = i = 0; (ch = msg[i]); i++) {
|
|
if (!in_body) {
|
|
/* author could be non 7-bit ASCII but
|
|
* the log may be so; skip over the
|
|
* header part first.
|
|
*/
|
|
if (ch == '\n' && msg[i+1] == '\n')
|
|
in_body = 1;
|
|
}
|
|
else if (non_ascii(ch)) {
|
|
need_8bit_cte = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pp_header(fmt, abbrev, dmode, encoding, commit, &msg, sb);
|
|
if (fmt != CMIT_FMT_ONELINE && !subject) {
|
|
strbuf_addch(sb, '\n');
|
|
}
|
|
|
|
/* Skip excess blank lines at the beginning of body, if any... */
|
|
msg = skip_empty_lines(msg);
|
|
|
|
/* These formats treat the title line specially. */
|
|
if (fmt == CMIT_FMT_ONELINE || fmt == CMIT_FMT_EMAIL)
|
|
pp_title_line(fmt, &msg, sb, subject,
|
|
after_subject, encoding, need_8bit_cte);
|
|
|
|
beginning_of_body = sb->len;
|
|
if (fmt != CMIT_FMT_ONELINE)
|
|
pp_remainder(fmt, &msg, sb, indent);
|
|
strbuf_rtrim(sb);
|
|
|
|
/* Make sure there is an EOLN for the non-oneline case */
|
|
if (fmt != CMIT_FMT_ONELINE)
|
|
strbuf_addch(sb, '\n');
|
|
|
|
/*
|
|
* The caller may append additional body text in e-mail
|
|
* format. Make sure we did not strip the blank line
|
|
* between the header and the body.
|
|
*/
|
|
if (fmt == CMIT_FMT_EMAIL && sb->len <= beginning_of_body)
|
|
strbuf_addch(sb, '\n');
|
|
free(reencoded);
|
|
}
|