mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Log message printout cleanups

Browse Source 
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().

Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.

The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like

	if (rev->logopt)
		show_log(rev, rev->logopt, "---\n");

but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.

That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:

	while ((commit = get_revision(rev)) != NULL) {
		log_tree_commit(rev, commit);
		free(commit->buffer);
		commit->buffer = NULL;
	}

so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.

I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.

This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.

Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
This commit is contained in:
Linus Torvalds
2006-04-17 11:59:32 -07:00
committed by Junio C Hamano
parent db89665fbf
commit 9153983310
11 changed files with 151 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
log-tree.c
View File

@ -1,11 +1,51 @@
#include "cache.h"
#include "diff.h"
#include "commit.h"
#include "log-tree.h"
void show_log(struct rev_info *opt, struct log_info *log, const char *sep)
{
static char this_header[16384];
struct commit *commit = log->commit, *parent = log->parent;
int abbrev = opt->diffopt.abbrev;
int abbrev_commit = opt->abbrev_commit ? opt->abbrev : 40;
int len;
opt->loginfo = NULL;
if (!opt->verbose_header) {
puts(sha1_to_hex(commit->object.sha1));
return;
}
/*
* Whitespace between commit messages, unless we are oneline
*/
if (opt->shown_one && opt->commit_format != CMIT_FMT_ONELINE)
putchar('\n');
opt->shown_one = 1;
/*
* Print header line of header..
*/
printf("%s%s",
opt->commit_format == CMIT_FMT_ONELINE ? "" : "commit ",
diff_unique_abbrev(commit->object.sha1, abbrev_commit));
if (parent)
printf(" (from %s)", diff_unique_abbrev(parent->object.sha1, abbrev_commit));
putchar(opt->commit_format == CMIT_FMT_ONELINE ? ' ' : '\n');
/*
* And then the pretty-printed message itself
*/
len = pretty_print_commit(opt->commit_format, commit, ~0u, this_header, sizeof(this_header), abbrev);
printf("%s%s", this_header, sep);
}
int log_tree_diff_flush(struct rev_info *opt)
{
diffcore_std(&opt->diffopt);
if (diff_queue_is_empty()) {
int saved_fmt = opt->diffopt.output_format;
opt->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
@ -13,12 +53,9 @@ int log_tree_diff_flush(struct rev_info *opt)
opt->diffopt.output_format = saved_fmt;
return 0;
}
if (opt->header) {
if (!opt->no_commit_id)
printf("%s%c", opt->header,
opt->diffopt.line_termination);
opt->header = NULL;
}
if (opt->loginfo && !opt->no_commit_id)
show_log(opt, opt->loginfo, "\n");
diff_flush(&opt->diffopt);
return 1;
}
@ -43,96 +80,78 @@ static int diff_root_tree(struct rev_info *opt,
return retval;
}
static const char *get_header(struct rev_info *opt,
const unsigned char *commit_sha1,
const unsigned char *parent_sha1,
const struct commit *commit)
{
static char this_header[16384];
int offset;
unsigned long len;
int abbrev = opt->diffopt.abbrev;
const char *msg = commit->buffer;
if (opt->use_precomputed_header)
return opt->use_precomputed_header;
if (!opt->verbose_header)
return sha1_to_hex(commit_sha1);
len = strlen(msg);
offset = sprintf(this_header, "%s%s ",
opt->header_prefix,
diff_unique_abbrev(commit_sha1, abbrev));
if (commit_sha1 != parent_sha1)
offset += sprintf(this_header + offset, "(from %s)\n",
parent_sha1
? diff_unique_abbrev(parent_sha1, abbrev)
: "root");
else
offset += sprintf(this_header + offset, "(from parents)\n");
offset += pretty_print_commit(opt->commit_format, commit, len,
this_header + offset,
sizeof(this_header) - offset, abbrev);
return this_header;
}
static const char *generate_header(struct rev_info *opt,
const unsigned char *commit_sha1,
const unsigned char *parent_sha1,
const struct commit *commit)
{
const char *header = get_header(opt, commit_sha1, parent_sha1, commit);
if (opt->always_show_header) {
puts(header);
header = NULL;
}
return header;
}
static int do_diff_combined(struct rev_info *opt, struct commit *commit)
{
unsigned const char *sha1 = commit->object.sha1;
opt->header = generate_header(opt, sha1, sha1, commit);
opt->header = diff_tree_combined_merge(sha1, opt->header,
opt->dense_combined_merges,
&opt->diffopt);
if (!opt->header && opt->verbose_header)
opt->header_prefix = "\ndiff-tree ";
return 0;
diff_tree_combined_merge(sha1, opt->dense_combined_merges, opt);
return !opt->loginfo;
}
int log_tree_commit(struct rev_info *opt, struct commit *commit)
/*
* Show the diff of a commit.
*
* Return true if we printed any log info messages
*/
static int log_tree_diff(struct rev_info *opt, struct commit *commit, struct log_info *log)
{
int showed_log;
struct commit_list *parents;
unsigned const char *sha1 = commit->object.sha1;
if (!opt->diff)
return 0;
/* Root commit? */
if (opt->show_root_diff && !commit->parents) {
opt->header = generate_header(opt, sha1, NULL, commit);
diff_root_tree(opt, sha1, "");
parents = commit->parents;
if (!parents) {
if (opt->show_root_diff)
diff_root_tree(opt, sha1, "");
return !opt->loginfo;
}
/* More than one parent? */
if (commit->parents && commit->parents->next) {
if (parents && parents->next) {
if (opt->ignore_merges)
return 0;
else if (opt->combine_merges)
return do_diff_combined(opt, commit);
/* If we show individual diffs, show the parent info */
log->parent = parents->item;
}
for (parents = commit->parents; parents; parents = parents->next) {
showed_log = 0;
for (;;) {
struct commit *parent = parents->item;
unsigned const char *psha1 = parent->object.sha1;
opt->header = generate_header(opt, sha1, psha1, commit);
diff_tree_sha1(psha1, sha1, "", &opt->diffopt);
log_tree_diff_flush(opt);
if (!opt->header && opt->verbose_header)
opt->header_prefix = "\ndiff-tree ";
diff_tree_sha1(parent->object.sha1, sha1, "", &opt->diffopt);
log_tree_diff_flush(opt);
showed_log |= !opt->loginfo;
/* Set up the log info for the next parent, if any.. */
parents = parents->next;
if (!parents)
break;
log->parent = parents->item;
opt->loginfo = log;
}
return showed_log;
}
int log_tree_commit(struct rev_info *opt, struct commit *commit)
{
struct log_info log;
log.commit = commit;
log.parent = NULL;
opt->loginfo = &log;
if (!log_tree_diff(opt, commit, &log) && opt->loginfo && opt->always_show_header) {
log.parent = NULL;
show_log(opt, opt->loginfo, "");
}
opt->loginfo = NULL;
return 0;
}