all repos — cgit @ ad74669e67ea08969776e6700ec37323e4935e23

a hyperfast web frontend for git written in c

ui-diff.c (view raw)

  1/* ui-diff.c: show diff between two blobs
  2 *
  3 * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
  4 *
  5 * Licensed under GNU General Public License v2
  6 *   (see COPYING for full license text)
  7 */
  8
  9#include "cgit.h"
 10#include "ui-diff.h"
 11#include "html.h"
 12#include "ui-shared.h"
 13#include "ui-ssdiff.h"
 14
 15unsigned char old_rev_sha1[20];
 16unsigned char new_rev_sha1[20];
 17
 18static int files, slots;
 19static int total_adds, total_rems, max_changes;
 20static int lines_added, lines_removed;
 21
 22static struct fileinfo {
 23	char status;
 24	unsigned char old_sha1[20];
 25	unsigned char new_sha1[20];
 26	unsigned short old_mode;
 27	unsigned short new_mode;
 28	char *old_path;
 29	char *new_path;
 30	unsigned int added;
 31	unsigned int removed;
 32	unsigned long old_size;
 33	unsigned long new_size;
 34	unsigned int binary:1;
 35} *items;
 36
 37static int use_ssdiff = 0;
 38static struct diff_filepair *current_filepair;
 39
 40struct diff_filespec *cgit_get_current_old_file(void)
 41{
 42	return current_filepair->one;
 43}
 44
 45struct diff_filespec *cgit_get_current_new_file(void)
 46{
 47	return current_filepair->two;
 48}
 49
 50static void print_fileinfo(struct fileinfo *info)
 51{
 52	char *class;
 53
 54	switch (info->status) {
 55	case DIFF_STATUS_ADDED:
 56		class = "add";
 57		break;
 58	case DIFF_STATUS_COPIED:
 59		class = "cpy";
 60		break;
 61	case DIFF_STATUS_DELETED:
 62		class = "del";
 63		break;
 64	case DIFF_STATUS_MODIFIED:
 65		class = "upd";
 66		break;
 67	case DIFF_STATUS_RENAMED:
 68		class = "mov";
 69		break;
 70	case DIFF_STATUS_TYPE_CHANGED:
 71		class = "typ";
 72		break;
 73	case DIFF_STATUS_UNKNOWN:
 74		class = "unk";
 75		break;
 76	case DIFF_STATUS_UNMERGED:
 77		class = "stg";
 78		break;
 79	default:
 80		die("bug: unhandled diff status %c", info->status);
 81	}
 82
 83	html("<tr>");
 84	htmlf("<td class='mode'>");
 85	if (is_null_sha1(info->new_sha1)) {
 86		cgit_print_filemode(info->old_mode);
 87	} else {
 88		cgit_print_filemode(info->new_mode);
 89	}
 90
 91	if (info->old_mode != info->new_mode &&
 92	    !is_null_sha1(info->old_sha1) &&
 93	    !is_null_sha1(info->new_sha1)) {
 94		html("<span class='modechange'>[");
 95		cgit_print_filemode(info->old_mode);
 96		html("]</span>");
 97	}
 98	htmlf("</td><td class='%s'>", class);
 99	cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.sha1,
100		       ctx.qry.sha2, info->new_path);
101	if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED) {
102		htmlf(" (%s from ",
103		      info->status == DIFF_STATUS_COPIED ? "copied" : "renamed");
104		html_txt(info->old_path);
105		html(")");
106	}
107	html("</td><td class='right'>");
108	if (info->binary) {
109		htmlf("bin</td><td class='graph'>%ld -> %ld bytes",
110		      info->old_size, info->new_size);
111		return;
112	}
113	htmlf("%d", info->added + info->removed);
114	html("</td><td class='graph'>");
115	htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes));
116	htmlf("<td class='add' style='width: %.1f%%;'/>",
117	      info->added * 100.0 / max_changes);
118	htmlf("<td class='rem' style='width: %.1f%%;'/>",
119	      info->removed * 100.0 / max_changes);
120	htmlf("<td class='none' style='width: %.1f%%;'/>",
121	      (max_changes - info->removed - info->added) * 100.0 / max_changes);
122	html("</tr></table></td></tr>\n");
123}
124
125static void count_diff_lines(char *line, int len)
126{
127	if (line && (len > 0)) {
128		if (line[0] == '+')
129			lines_added++;
130		else if (line[0] == '-')
131			lines_removed++;
132	}
133}
134
135static void inspect_filepair(struct diff_filepair *pair)
136{
137	int binary = 0;
138	unsigned long old_size = 0;
139	unsigned long new_size = 0;
140	files++;
141	lines_added = 0;
142	lines_removed = 0;
143	cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, &new_size,
144			&binary, 0, ctx.qry.ignorews, count_diff_lines);
145	if (files >= slots) {
146		if (slots == 0)
147			slots = 4;
148		else
149			slots = slots * 2;
150		items = xrealloc(items, slots * sizeof(struct fileinfo));
151	}
152	items[files-1].status = pair->status;
153	hashcpy(items[files-1].old_sha1, pair->one->sha1);
154	hashcpy(items[files-1].new_sha1, pair->two->sha1);
155	items[files-1].old_mode = pair->one->mode;
156	items[files-1].new_mode = pair->two->mode;
157	items[files-1].old_path = xstrdup(pair->one->path);
158	items[files-1].new_path = xstrdup(pair->two->path);
159	items[files-1].added = lines_added;
160	items[files-1].removed = lines_removed;
161	items[files-1].old_size = old_size;
162	items[files-1].new_size = new_size;
163	items[files-1].binary = binary;
164	if (lines_added + lines_removed > max_changes)
165		max_changes = lines_added + lines_removed;
166	total_adds += lines_added;
167	total_rems += lines_removed;
168}
169
170static void cgit_print_diffstat(const unsigned char *old_sha1,
171				const unsigned char *new_sha1,
172				const char *prefix)
173{
174	int i;
175
176	html("<div class='diffstat-header'>");
177	cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.sha1,
178		       ctx.qry.sha2, NULL);
179	if (prefix) {
180		html(" (limited to '");
181		html_txt(prefix);
182		html("')");
183	}
184	html("</div>");
185	html("<table summary='diffstat' class='diffstat'>");
186	max_changes = 0;
187	cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, prefix,
188		       ctx.qry.ignorews);
189	for (i = 0; i<files; i++)
190		print_fileinfo(&items[i]);
191	html("</table>");
192	html("<div class='diffstat-summary'>");
193	htmlf("%d files changed, %d insertions, %d deletions",
194	      files, total_adds, total_rems);
195	html("</div>");
196}
197
198
199/*
200 * print a single line returned from xdiff
201 */
202static void print_line(char *line, int len)
203{
204	char *class = "ctx";
205	char c = line[len-1];
206
207	if (line[0] == '+')
208		class = "add";
209	else if (line[0] == '-')
210		class = "del";
211	else if (line[0] == '@')
212		class = "hunk";
213
214	htmlf("<div class='%s'>", class);
215	line[len-1] = '\0';
216	html_txt(line);
217	html("</div>");
218	line[len-1] = c;
219}
220
221static void header(unsigned char *sha1, char *path1, int mode1,
222		   unsigned char *sha2, char *path2, int mode2)
223{
224	char *abbrev1, *abbrev2;
225	int subproject;
226
227	subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2));
228	html("<div class='head'>");
229	html("diff --git a/");
230	html_txt(path1);
231	html(" b/");
232	html_txt(path2);
233
234	if (mode1 == 0)
235		htmlf("<br/>new file mode %.6o", mode2);
236
237	if (mode2 == 0)
238		htmlf("<br/>deleted file mode %.6o", mode1);
239
240	if (!subproject) {
241		abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV));
242		abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV));
243		htmlf("<br/>index %s..%s", abbrev1, abbrev2);
244		free(abbrev1);
245		free(abbrev2);
246		if (mode1 != 0 && mode2 != 0) {
247			htmlf(" %.6o", mode1);
248			if (mode2 != mode1)
249				htmlf("..%.6o", mode2);
250		}
251		if (is_null_sha1(sha1)) {
252			path1 = "dev/null";
253			html("<br/>--- /");
254		} else
255			html("<br/>--- a/");
256		if (mode1 != 0)
257			cgit_tree_link(path1, NULL, NULL, ctx.qry.head,
258				       sha1_to_hex(old_rev_sha1), path1);
259		else
260			html_txt(path1);
261		if (is_null_sha1(sha2)) {
262			path2 = "dev/null";
263			html("<br/>+++ /");
264		} else
265			html("<br/>+++ b/");
266		if (mode2 != 0)
267			cgit_tree_link(path2, NULL, NULL, ctx.qry.head,
268				       sha1_to_hex(new_rev_sha1), path2);
269		else
270			html_txt(path2);
271	}
272	html("</div>");
273}
274
275static void filepair_cb(struct diff_filepair *pair)
276{
277	unsigned long old_size = 0;
278	unsigned long new_size = 0;
279	int binary = 0;
280	linediff_fn print_line_fn = print_line;
281
282	current_filepair = pair;
283	if (use_ssdiff) {
284		cgit_ssdiff_header_begin();
285		print_line_fn = cgit_ssdiff_line_cb;
286	}
287	header(pair->one->sha1, pair->one->path, pair->one->mode,
288	       pair->two->sha1, pair->two->path, pair->two->mode);
289	if (use_ssdiff)
290		cgit_ssdiff_header_end();
291	if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) {
292		if (S_ISGITLINK(pair->one->mode))
293			print_line_fn(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52);
294		if (S_ISGITLINK(pair->two->mode))
295			print_line_fn(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52);
296		if (use_ssdiff)
297			cgit_ssdiff_footer();
298		return;
299	}
300	if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
301			    &new_size, &binary, ctx.qry.context,
302			    ctx.qry.ignorews, print_line_fn))
303		cgit_print_error("Error running diff");
304	if (binary) {
305		if (use_ssdiff)
306			html("<tr><td colspan='4'>Binary files differ</td></tr>");
307		else
308			html("Binary files differ");
309	}
310	if (use_ssdiff)
311		cgit_ssdiff_footer();
312}
313
314void cgit_print_diff_ctrls(void)
315{
316	int i, curr;
317
318	html("<div class='cgit-panel'>");
319	html("<b>diff options</b>");
320	html("<form method='get' action='.'>");
321	cgit_add_hidden_formfields(1, 0, ctx.qry.page);
322	html("<table>");
323	html("<tr><td colspan='2'/></tr>");
324	html("<tr>");
325	html("<td class='label'>context:</td>");
326	html("<td class='ctrl'>");
327	html("<select name='context' onchange='this.form.submit();'>");
328	curr = ctx.qry.context;
329	if (!curr)
330		curr = 3;
331	for (i = 1; i <= 10; i++)
332		html_intoption(i, fmt("%d", i), curr);
333	for (i = 15; i <= 40; i += 5)
334		html_intoption(i, fmt("%d", i), curr);
335	html("</select>");
336	html("</td>");
337	html("</tr><tr>");
338	html("<td class='label'>space:</td>");
339	html("<td class='ctrl'>");
340	html("<select name='ignorews' onchange='this.form.submit();'>");
341	html_intoption(0, "include", ctx.qry.ignorews);
342	html_intoption(1, "ignore", ctx.qry.ignorews);
343	html("</select>");
344	html("</td>");
345	html("</tr><tr>");
346	html("<td class='label'>mode:</td>");
347	html("<td class='ctrl'>");
348	html("<select name='dt' onchange='this.form.submit();'>");
349	curr = ctx.qry.has_difftype ? ctx.qry.difftype : ctx.cfg.difftype;
350	html_intoption(0, "unified", curr);
351	html_intoption(1, "ssdiff", curr);
352	html_intoption(2, "stat only", curr);
353	html("</select></td></tr>");
354	html("<tr><td/><td class='ctrl'>");
355	html("<noscript><input type='submit' value='reload'/></noscript>");
356	html("</td></tr></table>");
357	html("</form>");
358	html("</div>");
359}
360
361void cgit_print_diff(const char *new_rev, const char *old_rev,
362		     const char *prefix, int show_ctrls, int raw)
363{
364	struct commit *commit, *commit2;
365	const unsigned char *old_tree_sha1, *new_tree_sha1;
366	diff_type difftype;
367
368	if (!new_rev)
369		new_rev = ctx.qry.head;
370	if (get_sha1(new_rev, new_rev_sha1)) {
371		cgit_print_error("Bad object name: %s", new_rev);
372		return;
373	}
374	commit = lookup_commit_reference(new_rev_sha1);
375	if (!commit || parse_commit(commit)) {
376		cgit_print_error("Bad commit: %s", sha1_to_hex(new_rev_sha1));
377		return;
378	}
379	new_tree_sha1 = commit->tree->object.sha1;
380
381	if (old_rev) {
382		if (get_sha1(old_rev, old_rev_sha1)) {
383			cgit_print_error("Bad object name: %s", old_rev);
384			return;
385		}
386	} else if (commit->parents && commit->parents->item) {
387		hashcpy(old_rev_sha1, commit->parents->item->object.sha1);
388	} else {
389		hashclr(old_rev_sha1);
390	}
391
392	if (!is_null_sha1(old_rev_sha1)) {
393		commit2 = lookup_commit_reference(old_rev_sha1);
394		if (!commit2 || parse_commit(commit2)) {
395			cgit_print_error("Bad commit: %s", sha1_to_hex(old_rev_sha1));
396			return;
397		}
398		old_tree_sha1 = commit2->tree->object.sha1;
399	} else {
400		old_tree_sha1 = NULL;
401	}
402
403	if (raw) {
404		struct diff_options diffopt;
405
406		diff_setup(&diffopt);
407		diffopt.output_format = DIFF_FORMAT_PATCH;
408		DIFF_OPT_SET(&diffopt, RECURSIVE);
409		diff_setup_done(&diffopt);
410
411		ctx.page.mimetype = "text/plain";
412		cgit_print_http_headers();
413		if (old_tree_sha1) {
414			diff_tree_sha1(old_tree_sha1, new_tree_sha1, "",
415				       &diffopt);
416		} else {
417			diff_root_tree_sha1(new_tree_sha1, "", &diffopt);
418		}
419		diffcore_std(&diffopt);
420		diff_flush(&diffopt);
421
422		return;
423	}
424
425	difftype = ctx.qry.has_difftype ? ctx.qry.difftype : ctx.cfg.difftype;
426	use_ssdiff = difftype == DIFF_SSDIFF;
427
428	if (show_ctrls)
429		cgit_print_diff_ctrls();
430
431	/*
432	 * Clicking on a link to a file in the diff stat should show a diff
433	 * of the file, showing the diff stat limited to a single file is
434	 * pretty useless.  All links from this point on will be to
435	 * individual files, so we simply reset the difftype in the query
436	 * here to avoid propagating DIFF_STATONLY to the individual files.
437	 */
438	if (difftype == DIFF_STATONLY)
439		ctx.qry.difftype = ctx.cfg.difftype;
440
441	cgit_print_diffstat(old_rev_sha1, new_rev_sha1, prefix);
442
443	if (difftype == DIFF_STATONLY)
444		return;
445
446	if (use_ssdiff) {
447		html("<table summary='ssdiff' class='ssdiff'>");
448	} else {
449		html("<table summary='diff' class='diff'>");
450		html("<tr><td>");
451	}
452	cgit_diff_tree(old_rev_sha1, new_rev_sha1, filepair_cb, prefix,
453		       ctx.qry.ignorews);
454	if (!use_ssdiff)
455		html("</td></tr>");
456	html("</table>");
457}