index : cgit

/*
 * The list of commits behind the log page and behind the recent commits on a
 * repository's summary page. Each commit becomes a table row, with optional
 * columns for the commit graph and for the files and lines it touched.
 * Following a single path lives here as well, because deciding whether a
 * commit belongs in a followed listing means diffing it against its parent
 * first. The branch and tag labels beside a commit are drawn here too, since
 * the commit page shows the same set.
 */

#define USE_THE_REPOSITORY_VARIABLE

#include "cgit.h"
#include "filter.h"
#include "html.h"
#include "parsing.h"
#include "shared.h"
#include "ui-log.h"
#include "ui-shared.h"

// A commit older than this is dated absolutely rather than relative to now.
#define MAX_RELATIVE_AGE (SECONDS_PER_WEEK * 2)

// Wrapping is skipped when max-message-len is under this, since the wrap
// symbol takes four bytes of whatever it allows.
#define MIN_WRAP_LEN 15

// git wants the index of the closing entry rather than a count, and it has to
// be handed these before the revision walk creates the graph.
static const char *column_colors_html[] = {
	"<span class='column1'>",
	"<span class='column2'>",
	"<span class='column3'>",
	"<span class='column4'>",
	"<span class='column5'>",
	"<span class='column6'>",
	"</span>",
};

#define COLUMN_COLORS_HTML_MAX (ARRAY_SIZE(column_colors_html) - 1)

// counts_ready says diff has already run for this commit, which happens when a
// path is being followed, so the row must not run it a second time.
static int file_count, added_lines, removed_lines, counts_ready;

static void count_line(char *line, int len)
{
	if (len <= 0)
		return;

	if (line[0] == '+')
		added_lines++;
	else if (line[0] == '-')
		removed_lines++;
}

static void count_file(struct diff_filepair *pair)
{
	// cgit_diff_files needs somewhere to report the blob sizes and
	// whether the pair is binary, none of which these columns show.
	unsigned long old_size = 0;
	unsigned long new_size = 0;
	int binary = 0;

	file_count++;
	if (ctx.repo->enable_log_linecount)
		cgit_diff_files(&pair->one->oid, &pair->two->oid, &old_size,
				&new_size, &binary, 0, ctx.qry.ignorews,
				count_line);
}

/*
 * Moves the query path to the name the file carries in the commit being
 * examined, so the commit and diff links in its row lead to the path that
 * commit knows.
 */
static void follow_path(struct diff_filepair *pair)
{
	if (strcmp(ctx.qry.vpath, pair->two->path) != 0) {
		// The first vpath is the same allocation as ctx.qry.path, so
		// freeing it here would leave that field pointing at memory
		// this function had already released.
		if (ctx.qry.vpath != ctx.qry.path)
			free(ctx.qry.vpath);
		ctx.qry.vpath = xstrdup(pair->two->path);
	}
	count_file(pair);
}

/*
 * Whether a commit belongs in the listing. When a single path is being
 * followed the commit is diffed against its one parent here, and the counts
 * that fall out of that diff are kept so the row does not repeat the work.
 */
static int should_show(struct commit *commit, struct rev_info *revs)
{
	struct commit_list *parents = commit->parents;
	struct commit *parent;
	int found = 0, saved_fmt;
	struct diff_flags saved_flags = revs->diffopt.flags;

	if (!ctx.qry.follow)
		return 1;

	// Merges are left out of a followed listing, which is what
	// git log --follow -- <file> does as well.
	if (parents && parents->next)
		return 0;

	if (!parents)
		return revs->show_root_diff;

	parent = parents->item;

	// A parent that does not parse is left for print_commit to report on,
	// so the commit is shown.
	if (repo_parse_commit(the_repository, parent))
		return 1;

	file_count = 0;
	added_lines = 0;
	removed_lines = 0;

	revs->diffopt.flags.recursive = 1;
	diff_tree_oid(get_commit_tree_oid(parent),
		      get_commit_tree_oid(commit),
		      "", &revs->diffopt);
	diffcore_std(&revs->diffopt);

	found = !diff_queue_is_empty(&revs->diffopt);
	saved_fmt = revs->diffopt.output_format;
	revs->diffopt.output_format = DIFF_FORMAT_CALLBACK;
	revs->diffopt.format_callback = cgit_diff_tree_cb;
	revs->diffopt.format_callback_data = follow_path;
	revs->diffopt.no_free = 1;
	diff_flush(&revs->diffopt);
	revs->diffopt.output_format = saved_fmt;
	revs->diffopt.flags = saved_flags;

	counts_ready = 1;
	return found;
}

/*
 * Draws the graph lines that belong above a commit. The line that carries the
 * commit itself stays in graph for the caller to place in the commit's own
 * row.
 */
static void print_graph_above(struct rev_info *revs, struct strbuf *graph,
			      int columns)
{
	while (!graph_next_line(revs->graph, graph)) {
		html("<tr class='nohover'><td class='commitgraph'>");
		html(graph->buf);
		// The graph cell is one of the columns, so the filler spans
		// the rest.
		htmlf("</td><td colspan='%d'></td></tr>\n", columns - 1);
		strbuf_setlen(graph, 0);
	}
}

/*
 * Cuts a subject longer than max-message-len down to size, leaving an arrow
 * where it was cut and moving the remainder to the front of msg. The subject
 * is edited in place, which the caller allows by freeing the commitinfo once
 * the row is written.
 */
static void wrap_subject(struct commitinfo *info, struct strbuf *msg)
{
	// The arrow is U+21B5 written out in PAGE_ENCODING.
	const char wrap_symbol[] = { ' ', 0xE2, 0x86, 0xB5, 0 };
	size_t subject_len = strlen(info->subject);
	int cut;

	if (ctx.cfg.max_msg_len < MIN_WRAP_LEN ||
	    subject_len <= (size_t)ctx.cfg.max_msg_len)
		return;

	cut = ctx.cfg.max_msg_len - strlen(wrap_symbol);

	while (cut > 0 && !isspace((unsigned char)info->subject[cut]))
		--cut;
	if (!cut)
		cut = ctx.cfg.max_msg_len - strlen(wrap_symbol);

	strbuf_add(msg, info->subject + cut, subject_len - cut);
	strbuf_trim(msg);
	strbuf_add(msg, "\n\n", 2);
	strlcpy(info->subject + cut, wrap_symbol, subject_len - cut + 1);
}

static int line_count(const char *text)
{
	int lines = 1;

	while ((text = strchr(text, '\n'))) {
		text++;
		lines++;
	}
	return lines;
}

static void print_graph_padding(struct rev_info *revs, struct strbuf *graph,
				int lines)
{
	html("<td class='commitgraph'>");
	while (lines > 0 || !graph_is_commit_finished(revs->graph)) {
		if (graph->len)
			html("\n");
		strbuf_setlen(graph, 0);
		graph_next_line(revs->graph, graph);
		html(graph->buf);
		lines--;
	}
	html("</td>\n");
}

static void print_commit(struct commit *commit, struct rev_info *revs)
{
	struct commitinfo *info;
	int columns = revs->graph ? 4 : 3;
	struct strbuf graphbuf = STRBUF_INIT;
	struct strbuf msgbuf = STRBUF_INIT;

	if (ctx.repo->enable_log_filecount)
		columns++;
	if (ctx.repo->enable_log_linecount)
		columns++;

	if (revs->graph)
		print_graph_above(revs, &graphbuf, columns);

	info = cgit_parse_commit(commit);
	htmlf("<tr%s>", ctx.qry.showmsg ? " class='logheader'" : "");

	if (revs->graph) {
		html("<td class='commitgraph'>");
		html(graphbuf.buf);
		html("</td>");
		strbuf_setlen(&graphbuf, 0);
	}
	else {
		html("<td>");
		cgit_print_age(info->committer_date, info->committer_tz,
			       MAX_RELATIVE_AGE);
		html("</td>");
	}

	htmlf("<td%s>", ctx.qry.showmsg ? " class='logsubject'" : "");
	if (ctx.qry.showmsg)
		wrap_subject(info, &msgbuf);
	cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head,
			 oid_to_hex(&commit->object.oid), ctx.qry.vpath);
	cgit_print_commit_decorations(commit);
	html("</td><td class='col-author'>");
	cgit_open_filter(ctx.repo->email_filter, info->author_email, "log");
	html_txt(info->author);
	cgit_close_filter(ctx.repo->email_filter);

	if (revs->graph) {
		html("</td><td>");
		cgit_print_age(info->committer_date, info->committer_tz,
			       MAX_RELATIVE_AGE);
	}

	if (!counts_ready && (ctx.repo->enable_log_filecount ||
			      ctx.repo->enable_log_linecount)) {
		file_count = 0;
		added_lines = 0;
		removed_lines = 0;
		cgit_diff_commit(commit, count_file, ctx.qry.vpath);
	}

	if (ctx.repo->enable_log_filecount)
		htmlf("</td><td class='col-count'>%d", file_count);
	if (ctx.repo->enable_log_linecount)
		htmlf("</td><td class='col-count'><span class='deletions'>-%d</span>/"
			"<span class='insertions'>+%d</span>",
			removed_lines, added_lines);

	html("</td></tr>\n");

	if ((revs->graph && !graph_is_commit_finished(revs->graph))
			|| ctx.qry.showmsg) {
		html("<tr class='nohover-highlight'>");

		if (ctx.qry.showmsg) {
			if (info->msg && *(info->msg)) {
				strbuf_addstr(&msgbuf, info->msg);
				strbuf_addch(&msgbuf, '\n');
			}
			format_display_notes(&commit->object.oid,
					     &msgbuf, PAGE_ENCODING, 0);
			strbuf_addch(&msgbuf, '\n');
			strbuf_ltrim(&msgbuf);
		}

		// With no graph the empty cell stands in for the age column.
		if (revs->graph) {
			int msg_lines = ctx.qry.showmsg ?
					line_count(msgbuf.buf) : 0;

			print_graph_padding(revs, &graphbuf, msg_lines);
		}
		else
			html("<td></td>");

		// Either way one cell is already on the row, so the message
		// spans the remaining columns.
		htmlf("<td colspan='%d'%s>\n", columns - 1,
			ctx.qry.showmsg ? " class='logmsg'" : "");
		html_txt(msgbuf.buf);
		html("</td></tr>\n");
	}

	strbuf_release(&msgbuf);
	strbuf_release(&graphbuf);
	cgit_free_commitinfo(info);
}

static const char *disambiguate_ref(const char *ref, int *must_free_result)
{
	struct object_id oid;
	struct strbuf longref = STRBUF_INIT;

	strbuf_addf(&longref, "refs/heads/%s", ref);
	if (repo_get_oid(the_repository, longref.buf, &oid) == 0) {
		*must_free_result = 1;
		return strbuf_detach(&longref, NULL);
	}

	*must_free_result = 0;
	strbuf_release(&longref);
	return ref;
}

static char *next_token(char **src)
{
	char *token;

	if (!src || !*src)
		return NULL;
	while (isspace((unsigned char)**src))
		(*src)++;
	if (!**src)
		return NULL;
	token = *src;
	while (**src) {
		if (isspace((unsigned char)**src)) {
			**src = '\0';
			(*src)++;
			break;
		}
		(*src)++;
	}
	return token;
}

/*
 * Whether there is a page after this one is answered by pulling one more
 * commit off the walk.
 */
static void print_pager(struct rev_info *revs, int ofs, int cnt)
{
	struct commit *commit;

	html("</table><ul class='pager'>");
	if (ofs > 0) {
		html("<li>");
		cgit_log_link("[prev]", NULL, NULL, ctx.qry.head,
			      ctx.qry.oid, ctx.qry.vpath,
			      ofs - cnt, ctx.qry.grep,
			      ctx.qry.search, ctx.qry.showmsg,
			      ctx.qry.follow);
		html("</li>");
	}
	if ((commit = get_revision(revs)) != NULL) {
		html("<li>");
		cgit_log_link("[next]", NULL, NULL, ctx.qry.head,
			      ctx.qry.oid, ctx.qry.vpath,
			      ofs + cnt, ctx.qry.grep,
			      ctx.qry.search, ctx.qry.showmsg,
			      ctx.qry.follow);
		html("</li>");
	}
	html("</ul>");
}

/*
 * The caller has to have loaded the ref decorations for the walk, since
 * without them a commit carries none.
 */
void cgit_print_commit_decorations(struct commit *commit)
{
	const struct name_decoration *deco;
	static char buf[1024];

	buf[sizeof(buf) - 1] = 0;
	deco = get_name_decoration(&commit->object);
	if (!deco)
		return;
	html("<span class='decoration'>");
	while (deco) {
		struct object_id oid_tag, peeled;
		int is_annotated = 0;

		strlcpy(buf, prettify_refname(deco->name), sizeof(buf));
		switch (deco->type) {
		case DECORATION_NONE:
			break;
		case DECORATION_REF_LOCAL:
			cgit_log_link(buf, NULL, "branch-deco", buf, NULL,
				ctx.qry.vpath, 0, NULL, NULL,
				ctx.qry.showmsg, 0);
			break;
		case DECORATION_REF_TAG:
			if (!refs_read_ref(get_main_ref_store(the_repository),
					   deco->name, &oid_tag) &&
			    !peel_object(the_repository, &oid_tag, &peeled,
					 PEEL_OBJECT_VERIFY_TAGGED_OBJECT_TYPE))
				is_annotated = !oideq(&oid_tag, &peeled);
			cgit_tag_link(buf, NULL, is_annotated ?
				      "tag-annotated-deco" : "tag-deco", buf);
			break;
		case DECORATION_REF_REMOTE:
			if (!ctx.repo->enable_remote_branches)
				break;
			cgit_log_link(buf, NULL, "remote-deco", NULL,
				oid_to_hex(&commit->object.oid),
				ctx.qry.vpath, 0, NULL, NULL,
				ctx.qry.showmsg, 0);
			break;
		default:
			cgit_commit_link(buf, NULL, "deco", ctx.qry.head,
					oid_to_hex(&commit->object.oid),
					ctx.qry.vpath);
			break;
		}
		deco = deco->next;
	}
	html("</span>");
}

void cgit_print_log(const char *tip, int ofs, int cnt, char *grep,
		    char *pattern, const char *path, int pager,
		    int commit_graph, int commit_sort)
{
	struct rev_info rev;
	struct commit *commit;
	struct strvec rev_argv = STRVEC_INIT;
	int i, columns = commit_graph ? 4 : 3;
	int must_free_tip = 0;

	// setup_revisions skips the first entry the way a command skips its
	// own name, so this one is only a placeholder.
	strvec_push(&rev_argv, "log_rev_setup");

	if (!tip)
		tip = ctx.qry.head;
	tip = disambiguate_ref(tip, &must_free_tip);
	if (tip && tip[0] == '-') {
		// setup_revisions() reads a leading-dash argument as an
		// option, so a tip arriving as the id= value "--output=<path>"
		// would be handled by git as a request to write an arbitrary
		// file. No valid ref or object name begins with a dash, so
		// refuse it.
		cgit_print_error_page(400, "Bad request", "Invalid revision");
		if (must_free_tip)
			free((char *)tip);
		strvec_clear(&rev_argv);
		return;
	}
	strvec_push(&rev_argv, tip);

	if (grep && pattern && *pattern) {
		pattern = xstrdup(pattern);
		if (!strcmp(grep, "grep") || !strcmp(grep, "author") ||
		    !strcmp(grep, "committer")) {
			strvec_pushf(&rev_argv, "--%s=%s", grep, pattern);
		} else if (!strcmp(grep, "range")) {
			char *arg;

			// Each whitespace separated token is taken as a
			// revision expression and nothing else, since anything
			// starting with a dash would reach setup_revisions as
			// a rev-list option. The tip pushed above goes away
			// because the range supersedes it.
			strvec_pop(&rev_argv);
			while ((arg = next_token(&pattern))) {
				if (*arg == '-') {
					fprintf(stderr, "Bad range expr: %s\n",
						arg);
					break;
				}
				strvec_push(&rev_argv, arg);
			}
		}
	}

	if (!path || !ctx.repo->enable_follow_links)
		ctx.qry.follow = 0;

	if (commit_graph && !ctx.qry.follow) {
		strvec_push(&rev_argv, "--graph");
		strvec_push(&rev_argv, "--color");
		graph_set_column_colors(column_colors_html,
					COLUMN_COLORS_HTML_MAX);
	}

	if (commit_sort == 1)
		strvec_push(&rev_argv, "--date-order");
	else if (commit_sort == 2)
		strvec_push(&rev_argv, "--topo-order");

	if (path && ctx.qry.follow)
		strvec_push(&rev_argv, "--follow");
	strvec_push(&rev_argv, "--");
	if (path)
		strvec_push(&rev_argv, path);

	repo_init_revisions(the_repository, &rev, NULL);
	rev.abbrev = DEFAULT_ABBREV;
	rev.commit_format = CMIT_FMT_DEFAULT;
	rev.verbose_header = 1;
	rev.show_root_diff = 0;
	rev.ignore_missing = 1;
	rev.simplify_history = 1;
	setup_revisions(rev_argv.nr, rev_argv.v, &rev, NULL);
	load_ref_decorations(NULL, DECORATE_FULL_REFS);
	rev.show_decorations = 1;
	rev.grep_filter.ignore_case = 1;

	rev.diffopt.detect_rename = 1;
	rev.diffopt.rename_limit = ctx.cfg.renamelimit;
	if (ctx.qry.ignorews)
		DIFF_XDL_SET(&rev.diffopt, IGNORE_WHITESPACE);

	compile_grep_patterns(&rev.grep_filter);
	prepare_revision_walk(&rev);

	if (pager) {
		cgit_print_layout_start();
		html("<table class='list'>");
	}

	html("<tr class='nohover'>");
	if (commit_graph)
		html("<th></th>");
	else
		html("<th class='left'>Age</th>");
	html("<th class='left'>Commit message");
	if (pager) {
		html(" (");
		cgit_log_link(ctx.qry.showmsg ? "Collapse" : "Expand", NULL,
			      NULL, ctx.qry.head, ctx.qry.oid,
			      ctx.qry.vpath, ctx.qry.ofs, ctx.qry.grep,
			      ctx.qry.search, ctx.qry.showmsg ? 0 : 1,
			      ctx.qry.follow);
		html(")");
	}
	html("</th><th class='left col-author'>Author</th>");
	if (rev.graph)
		html("<th class='left'>Age</th>");
	if (ctx.repo->enable_log_filecount) {
		html("<th class='left col-count'>Files</th>");
		columns++;
	}
	if (ctx.repo->enable_log_linecount) {
		html("<th class='left col-count'>Lines</th>");
		columns++;
	}
	html("</tr>\n");

	if (ofs < 0)
		ofs = 0;

	for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; ) {
		if (should_show(commit, &rev))
			i++;
		release_commit_memory(the_repository->parsed_objects, commit);
		commit->parents = NULL;
	}

	for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; ) {
		// Clearing the flag per commit keeps a commit from being
		// diffed twice when the file or line columns are on.
		counts_ready = 0;
		if (should_show(commit, &rev)) {
			i++;
			print_commit(commit, &rev);
		}
		release_commit_memory(the_repository->parsed_objects, commit);
		commit->parents = NULL;
	}
	if (pager) {
		print_pager(&rev, ofs, cnt);
		cgit_print_layout_end();
	} else if ((commit = get_revision(&rev)) != NULL) {
		htmlf("<tr class='nohover'><td colspan='%d'>", columns);
		cgit_log_link("[...]", NULL, NULL, ctx.qry.head, NULL,
			      ctx.qry.vpath, 0, NULL, NULL, ctx.qry.showmsg,
			      ctx.qry.follow);
		html("</td></tr>\n");
	}

	// The cast is safe because must_free_tip is only set for a string this
	// function allocated.
	if (must_free_tip)
		free((char *)tip);
}