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.
	size_t old_size = 0;
	size_t 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, or against the
 * empty tree when it is the root, 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)
{
	// Static, because the walk keeps the address in its diff options.
	static filepair_fn follow = follow_path;
	struct commit_list *parents = commit->parents;
	const struct object_id *parent_tree = NULL;
	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) {
		// 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, parents->item))
			return 1;
		parent_tree = get_commit_tree_oid(parents->item);
	}

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

	revs->diffopt.flags.recursive = 1;
	diff_tree_oid(parent_tree, 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;
	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
 * ellipsis 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)
{
	const char wrap_symbol[] = " ...";
	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);
	// A cut inside a multibyte character would leave both halves invalid.
	while (cut > 0 && (info->subject[cut] & 0xC0) == 0x80)
		--cut;

	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 class='commit%s'>", ctx.qry.showmsg ? " 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 ? 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;
}

/*
 * A range token is one revision, or two joined by two or three dots, and each
 * side has to pass cgit_valid_rev. An empty side means HEAD to git.
 */
static int valid_range_token(const char *arg)
{
	const char *dots = strstr(arg, "..");
	char *left;
	int ok;

	if (!dots)
		return cgit_valid_rev(arg);
	left = xstrndup(arg, dots - arg);
	dots += 2;
	if (*dots == '.')
		dots++;
	ok = (!*left || cgit_valid_rev(left)) && (!*dots || cgit_valid_rev(dots));
	free(left);
	return ok;
}

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

	if (!*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. The links carry the path as it was asked for, since a
 * followed rename leaves ctx.qry.vpath at the name the last row's commit knew.
 */
static void print_pager(struct rev_info *revs, const char *path, int ofs, int cnt)
{
	struct commit *more = get_revision(revs);

	html("</tbody>\n</table>\n");
	// A single page needs no pager, and an empty list has nothing to page.
	if (ofs <= 0 && !more)
		return;
	html("<nav class='pager' aria-label='Pager'><ul>");
	if (ofs > 0) {
		html("<li>");
		cgit_log_link(
			"[prev]", NULL, NULL, ctx.qry.head, ctx.qry.oid, path,
			ofs - cnt, ctx.qry.grep, ctx.qry.search, ctx.qry.showmsg, ctx.qry.follow
		);
		html("</li>");
	}
	if (more) {
		html("<li>");
		cgit_log_link(
			"[next]", NULL, NULL, ctx.qry.head, ctx.qry.oid, path,
			ofs + cnt, ctx.qry.grep, ctx.qry.search, ctx.qry.showmsg, ctx.qry.follow
		);
		html("</li>");
	}
	html("</ul></nav>");
}

/*
 * 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;
	const char *buf;

	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;

		buf = prettify_refname(deco->name);
		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);
	// Checked here as well as in prepare_repo_cmd, since a caller can pass
	// a tip of its own and setup_revisions reads a leading dash as an
	// option.
	if (tip && !cgit_valid_rev(tip)) {
		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);

	// A leading colon makes git read the path as a pathspec with magic,
	// which can end the request inside git.
	if (path && path[0] == ':') {
		cgit_print_error_page(400, "Bad Request", "Invalid path");
		if (must_free_tip)
			free((char *)tip);
		strvec_clear(&rev_argv);
		return;
	}

	if (grep && pattern && *pattern) {
		pattern = xstrdup(pattern);
		if (!strcmp(grep, "grep") || !strcmp(grep, "author") || !strcmp(grep, "committer")) {
			// The search is literal and ignores case. setup_revisions
			// compiles the pattern, so the flags go in with it.
			strvec_push(&rev_argv, "--fixed-strings");
			strvec_push(&rev_argv, "--regexp-ignore-case");
			strvec_pushf(&rev_argv, "--%s=%s", grep, pattern);
		} else if (!strcmp(grep, "range")) {
			char *arg;

			// Each whitespace separated token has to pass the same
			// check as any other revision. The tip pushed above goes
			// away, since the range supersedes it.
			strvec_pop(&rev_argv);
			while ((arg = next_token(&pattern))) {
				if (!valid_range_token(arg)) {
					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, 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);
	// The author and committer searches then match the mapped idents.
	rev.mailmap = cgit_mailmap();
	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.diffopt.detect_rename = 1;
	rev.diffopt.rename_limit = ctx.cfg.renamelimit;
	if (ctx.qry.ignorews)
		DIFF_XDL_SET(&rev.diffopt, IGNORE_WHITESPACE);

	// A failed setup leaves the walk holding freed commits, so it must
	// not be read from.
	if (prepare_revision_walk(&rev)) {
		cgit_print_error_page(500, "Internal Server Error", "Unable to read the history");
		strvec_clear(&rev_argv);
		return;
	}

	if (pager) {
		cgit_print_layout_start();
		html("<table class='list log' aria-label='Commits'>\n");
	}

	html("<tbody class='log'>\n<tr class='nohover'>");
	if (commit_graph)
		html("<th></th>");
	else
		html("<th class='left' scope='col'>Age</th>");
	html("<th class='left' scope='col'>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' scope='col'>Author</th>");
	if (rev.graph)
		html("<th class='left' scope='col'>Age</th>");
	if (ctx.repo->enable_log_filecount) {
		html("<th class='left col-count' scope='col'>Files</th>");
		columns++;
	}
	if (ctx.repo->enable_log_linecount) {
		html("<th class='left col-count' scope='col'>Lines</th>");
		columns++;
	}
	html("</tr>\n");

	if (ofs < 0)
		ofs = 0;

	for (i = 0; i < ofs && (commit = get_revision(&rev)); ) {
		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)); ) {
		// 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, path, ofs, cnt);
		cgit_print_layout_end();
	} else {
		if (get_revision(&rev)) {
			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");
		}
		html("</tbody>\n");
	}

	if (must_free_tip)
		free((char *)tip);
}