author | Lars Hjemli <hjemli@gmail.com> | 2009-01-31 09:40:40 (UTC) |
---|---|---|
committer | Lars Hjemli <hjemli@gmail.com> | 2009-01-31 09:40:40 (UTC) |
commit | c495cf02bac16e459f7c9e1740798646f12c00c5 (patch) (unidiff) | |
tree | a36ba3904edd96ffc79fdf420fb10d33117a469f | |
parent | d6174b7aab476c2b6a86e59d98cf978d603045f4 (diff) | |
download | cgit-c495cf02bac16e459f7c9e1740798646f12c00c5.zip cgit-c495cf02bac16e459f7c9e1740798646f12c00c5.tar.gz cgit-c495cf02bac16e459f7c9e1740798646f12c00c5.tar.bz2 |
Handle binary files in diffs
This teaches all diff-related operations (i.e. ui-log, ui-diff and ui-patch)
how to handle binary files.
Signed-off-by: Lars Hjemli <hjemli@gmail.com>
-rw-r--r-- | cgit.h | 4 | ||||
-rw-r--r-- | shared.c | 13 | ||||
-rw-r--r-- | ui-diff.c | 26 | ||||
-rw-r--r-- | ui-log.c | 7 | ||||
-rw-r--r-- | ui-patch.c | 9 |
5 files changed, 52 insertions, 7 deletions
@@ -1,65 +1,66 @@ | |||
1 | #ifndef CGIT_H | 1 | #ifndef CGIT_H |
2 | #define CGIT_H | 2 | #define CGIT_H |
3 | 3 | ||
4 | 4 | ||
5 | #include <git-compat-util.h> | 5 | #include <git-compat-util.h> |
6 | #include <cache.h> | 6 | #include <cache.h> |
7 | #include <grep.h> | 7 | #include <grep.h> |
8 | #include <object.h> | 8 | #include <object.h> |
9 | #include <tree.h> | 9 | #include <tree.h> |
10 | #include <commit.h> | 10 | #include <commit.h> |
11 | #include <tag.h> | 11 | #include <tag.h> |
12 | #include <diff.h> | 12 | #include <diff.h> |
13 | #include <diffcore.h> | 13 | #include <diffcore.h> |
14 | #include <refs.h> | 14 | #include <refs.h> |
15 | #include <revision.h> | 15 | #include <revision.h> |
16 | #include <log-tree.h> | 16 | #include <log-tree.h> |
17 | #include <archive.h> | 17 | #include <archive.h> |
18 | #include <xdiff-interface.h> | ||
18 | #include <xdiff/xdiff.h> | 19 | #include <xdiff/xdiff.h> |
19 | #include <utf8.h> | 20 | #include <utf8.h> |
20 | 21 | ||
21 | 22 | ||
22 | /* | 23 | /* |
23 | * Dateformats used on misc. pages | 24 | * Dateformats used on misc. pages |
24 | */ | 25 | */ |
25 | #define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)" | 26 | #define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)" |
26 | #define FMT_SHORTDATE "%Y-%m-%d" | 27 | #define FMT_SHORTDATE "%Y-%m-%d" |
27 | #define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ" | 28 | #define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ" |
28 | 29 | ||
29 | 30 | ||
30 | /* | 31 | /* |
31 | * Limits used for relative dates | 32 | * Limits used for relative dates |
32 | */ | 33 | */ |
33 | #define TM_MIN 60 | 34 | #define TM_MIN 60 |
34 | #define TM_HOUR (TM_MIN * 60) | 35 | #define TM_HOUR (TM_MIN * 60) |
35 | #define TM_DAY (TM_HOUR * 24) | 36 | #define TM_DAY (TM_HOUR * 24) |
36 | #define TM_WEEK (TM_DAY * 7) | 37 | #define TM_WEEK (TM_DAY * 7) |
37 | #define TM_YEAR (TM_DAY * 365) | 38 | #define TM_YEAR (TM_DAY * 365) |
38 | #define TM_MONTH (TM_YEAR / 12.0) | 39 | #define TM_MONTH (TM_YEAR / 12.0) |
39 | 40 | ||
40 | 41 | ||
41 | /* | 42 | /* |
42 | * Default encoding | 43 | * Default encoding |
43 | */ | 44 | */ |
44 | #define PAGE_ENCODING "UTF-8" | 45 | #define PAGE_ENCODING "UTF-8" |
45 | 46 | ||
46 | typedef void (*configfn)(const char *name, const char *value); | 47 | typedef void (*configfn)(const char *name, const char *value); |
47 | typedef void (*filepair_fn)(struct diff_filepair *pair); | 48 | typedef void (*filepair_fn)(struct diff_filepair *pair); |
48 | typedef void (*linediff_fn)(char *line, int len); | 49 | typedef void (*linediff_fn)(char *line, int len); |
49 | 50 | ||
50 | struct cgit_repo { | 51 | struct cgit_repo { |
51 | char *url; | 52 | char *url; |
52 | char *name; | 53 | char *name; |
53 | char *path; | 54 | char *path; |
54 | char *desc; | 55 | char *desc; |
55 | char *owner; | 56 | char *owner; |
56 | char *defbranch; | 57 | char *defbranch; |
57 | char *group; | 58 | char *group; |
58 | char *module_link; | 59 | char *module_link; |
59 | char *readme; | 60 | char *readme; |
60 | char *clone_url; | 61 | char *clone_url; |
61 | int snapshots; | 62 | int snapshots; |
62 | int enable_log_filecount; | 63 | int enable_log_filecount; |
63 | int enable_log_linecount; | 64 | int enable_log_linecount; |
64 | int max_stats; | 65 | int max_stats; |
65 | time_t mtime; | 66 | time_t mtime; |
@@ -176,68 +177,69 @@ struct cgit_page { | |||
176 | time_t expires; | 177 | time_t expires; |
177 | size_t size; | 178 | size_t size; |
178 | char *mimetype; | 179 | char *mimetype; |
179 | char *charset; | 180 | char *charset; |
180 | char *filename; | 181 | char *filename; |
181 | char *title; | 182 | char *title; |
182 | }; | 183 | }; |
183 | 184 | ||
184 | struct cgit_context { | 185 | struct cgit_context { |
185 | struct cgit_query qry; | 186 | struct cgit_query qry; |
186 | struct cgit_config cfg; | 187 | struct cgit_config cfg; |
187 | struct cgit_repo *repo; | 188 | struct cgit_repo *repo; |
188 | struct cgit_page page; | 189 | struct cgit_page page; |
189 | }; | 190 | }; |
190 | 191 | ||
191 | struct cgit_snapshot_format { | 192 | struct cgit_snapshot_format { |
192 | const char *suffix; | 193 | const char *suffix; |
193 | const char *mimetype; | 194 | const char *mimetype; |
194 | write_archive_fn_t write_func; | 195 | write_archive_fn_t write_func; |
195 | int bit; | 196 | int bit; |
196 | }; | 197 | }; |
197 | 198 | ||
198 | extern const char *cgit_version; | 199 | extern const char *cgit_version; |
199 | 200 | ||
200 | extern struct cgit_repolist cgit_repolist; | 201 | extern struct cgit_repolist cgit_repolist; |
201 | extern struct cgit_context ctx; | 202 | extern struct cgit_context ctx; |
202 | extern const struct cgit_snapshot_format cgit_snapshot_formats[]; | 203 | extern const struct cgit_snapshot_format cgit_snapshot_formats[]; |
203 | 204 | ||
204 | extern struct cgit_repo *cgit_add_repo(const char *url); | 205 | extern struct cgit_repo *cgit_add_repo(const char *url); |
205 | extern struct cgit_repo *cgit_get_repoinfo(const char *url); | 206 | extern struct cgit_repo *cgit_get_repoinfo(const char *url); |
206 | extern void cgit_repo_config_cb(const char *name, const char *value); | 207 | extern void cgit_repo_config_cb(const char *name, const char *value); |
207 | 208 | ||
208 | extern int chk_zero(int result, char *msg); | 209 | extern int chk_zero(int result, char *msg); |
209 | extern int chk_positive(int result, char *msg); | 210 | extern int chk_positive(int result, char *msg); |
210 | extern int chk_non_negative(int result, char *msg); | 211 | extern int chk_non_negative(int result, char *msg); |
211 | 212 | ||
212 | extern char *trim_end(const char *str, char c); | 213 | extern char *trim_end(const char *str, char c); |
213 | extern char *strlpart(char *txt, int maxlen); | 214 | extern char *strlpart(char *txt, int maxlen); |
214 | extern char *strrpart(char *txt, int maxlen); | 215 | extern char *strrpart(char *txt, int maxlen); |
215 | 216 | ||
216 | extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); | 217 | extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); |
217 | extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, | 218 | extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, |
218 | int flags, void *cb_data); | 219 | int flags, void *cb_data); |
219 | 220 | ||
220 | extern void *cgit_free_commitinfo(struct commitinfo *info); | 221 | extern void *cgit_free_commitinfo(struct commitinfo *info); |
221 | 222 | ||
222 | extern int cgit_diff_files(const unsigned char *old_sha1, | 223 | extern int cgit_diff_files(const unsigned char *old_sha1, |
223 | const unsigned char *new_sha1, | 224 | const unsigned char *new_sha1, |
224 | linediff_fn fn); | 225 | unsigned long *old_size, unsigned long *new_size, |
226 | int *binary, linediff_fn fn); | ||
225 | 227 | ||
226 | extern void cgit_diff_tree(const unsigned char *old_sha1, | 228 | extern void cgit_diff_tree(const unsigned char *old_sha1, |
227 | const unsigned char *new_sha1, | 229 | const unsigned char *new_sha1, |
228 | filepair_fn fn, const char *prefix); | 230 | filepair_fn fn, const char *prefix); |
229 | 231 | ||
230 | extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); | 232 | extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); |
231 | 233 | ||
232 | extern char *fmt(const char *format,...); | 234 | extern char *fmt(const char *format,...); |
233 | 235 | ||
234 | extern struct commitinfo *cgit_parse_commit(struct commit *commit); | 236 | extern struct commitinfo *cgit_parse_commit(struct commit *commit); |
235 | extern struct taginfo *cgit_parse_tag(struct tag *tag); | 237 | extern struct taginfo *cgit_parse_tag(struct tag *tag); |
236 | extern void cgit_parse_url(const char *url); | 238 | extern void cgit_parse_url(const char *url); |
237 | 239 | ||
238 | extern const char *cgit_repobasename(const char *reponame); | 240 | extern const char *cgit_repobasename(const char *reponame); |
239 | 241 | ||
240 | extern int cgit_parse_snapshots_mask(const char *str); | 242 | extern int cgit_parse_snapshots_mask(const char *str); |
241 | 243 | ||
242 | 244 | ||
243 | #endif /* CGIT_H */ | 245 | #endif /* CGIT_H */ |
@@ -212,107 +212,116 @@ static int load_mmfile(mmfile_t *file, const unsigned char *sha1) | |||
212 | } | 212 | } |
213 | 213 | ||
214 | /* | 214 | /* |
215 | * Receive diff-buffers from xdiff and concatenate them as | 215 | * Receive diff-buffers from xdiff and concatenate them as |
216 | * needed across multiple callbacks. | 216 | * needed across multiple callbacks. |
217 | * | 217 | * |
218 | * This is basically a copy of xdiff-interface.c/xdiff_outf(), | 218 | * This is basically a copy of xdiff-interface.c/xdiff_outf(), |
219 | * ripped from git and modified to use globals instead of | 219 | * ripped from git and modified to use globals instead of |
220 | * a special callback-struct. | 220 | * a special callback-struct. |
221 | */ | 221 | */ |
222 | char *diffbuf = NULL; | 222 | char *diffbuf = NULL; |
223 | int buflen = 0; | 223 | int buflen = 0; |
224 | 224 | ||
225 | int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) | 225 | int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) |
226 | { | 226 | { |
227 | int i; | 227 | int i; |
228 | 228 | ||
229 | for (i = 0; i < nbuf; i++) { | 229 | for (i = 0; i < nbuf; i++) { |
230 | if (mb[i].ptr[mb[i].size-1] != '\n') { | 230 | if (mb[i].ptr[mb[i].size-1] != '\n') { |
231 | /* Incomplete line */ | 231 | /* Incomplete line */ |
232 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); | 232 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); |
233 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); | 233 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); |
234 | buflen += mb[i].size; | 234 | buflen += mb[i].size; |
235 | continue; | 235 | continue; |
236 | } | 236 | } |
237 | 237 | ||
238 | /* we have a complete line */ | 238 | /* we have a complete line */ |
239 | if (!diffbuf) { | 239 | if (!diffbuf) { |
240 | ((linediff_fn)priv)(mb[i].ptr, mb[i].size); | 240 | ((linediff_fn)priv)(mb[i].ptr, mb[i].size); |
241 | continue; | 241 | continue; |
242 | } | 242 | } |
243 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); | 243 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); |
244 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); | 244 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); |
245 | ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); | 245 | ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); |
246 | free(diffbuf); | 246 | free(diffbuf); |
247 | diffbuf = NULL; | 247 | diffbuf = NULL; |
248 | buflen = 0; | 248 | buflen = 0; |
249 | } | 249 | } |
250 | if (diffbuf) { | 250 | if (diffbuf) { |
251 | ((linediff_fn)priv)(diffbuf, buflen); | 251 | ((linediff_fn)priv)(diffbuf, buflen); |
252 | free(diffbuf); | 252 | free(diffbuf); |
253 | diffbuf = NULL; | 253 | diffbuf = NULL; |
254 | buflen = 0; | 254 | buflen = 0; |
255 | } | 255 | } |
256 | return 0; | 256 | return 0; |
257 | } | 257 | } |
258 | 258 | ||
259 | int cgit_diff_files(const unsigned char *old_sha1, | 259 | int cgit_diff_files(const unsigned char *old_sha1, |
260 | const unsigned char *new_sha1, | 260 | const unsigned char *new_sha1, unsigned long *old_size, |
261 | linediff_fn fn) | 261 | unsigned long *new_size, int *binary, linediff_fn fn) |
262 | { | 262 | { |
263 | mmfile_t file1, file2; | 263 | mmfile_t file1, file2; |
264 | xpparam_t diff_params; | 264 | xpparam_t diff_params; |
265 | xdemitconf_t emit_params; | 265 | xdemitconf_t emit_params; |
266 | xdemitcb_t emit_cb; | 266 | xdemitcb_t emit_cb; |
267 | 267 | ||
268 | if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) | 268 | if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) |
269 | return 1; | 269 | return 1; |
270 | 270 | ||
271 | *old_size = file1.size; | ||
272 | *new_size = file2.size; | ||
273 | |||
274 | if (buffer_is_binary(file1.ptr, file1.size) || | ||
275 | buffer_is_binary(file2.ptr, file2.size)) { | ||
276 | *binary = 1; | ||
277 | return 0; | ||
278 | } | ||
279 | |||
271 | memset(&diff_params, 0, sizeof(diff_params)); | 280 | memset(&diff_params, 0, sizeof(diff_params)); |
272 | memset(&emit_params, 0, sizeof(emit_params)); | 281 | memset(&emit_params, 0, sizeof(emit_params)); |
273 | memset(&emit_cb, 0, sizeof(emit_cb)); | 282 | memset(&emit_cb, 0, sizeof(emit_cb)); |
274 | diff_params.flags = XDF_NEED_MINIMAL; | 283 | diff_params.flags = XDF_NEED_MINIMAL; |
275 | emit_params.ctxlen = 3; | 284 | emit_params.ctxlen = 3; |
276 | emit_params.flags = XDL_EMIT_FUNCNAMES; | 285 | emit_params.flags = XDL_EMIT_FUNCNAMES; |
277 | emit_cb.outf = filediff_cb; | 286 | emit_cb.outf = filediff_cb; |
278 | emit_cb.priv = fn; | 287 | emit_cb.priv = fn; |
279 | xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); | 288 | xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); |
280 | return 0; | 289 | return 0; |
281 | } | 290 | } |
282 | 291 | ||
283 | void cgit_diff_tree(const unsigned char *old_sha1, | 292 | void cgit_diff_tree(const unsigned char *old_sha1, |
284 | const unsigned char *new_sha1, | 293 | const unsigned char *new_sha1, |
285 | filepair_fn fn, const char *prefix) | 294 | filepair_fn fn, const char *prefix) |
286 | { | 295 | { |
287 | struct diff_options opt; | 296 | struct diff_options opt; |
288 | int ret; | 297 | int ret; |
289 | int prefixlen; | 298 | int prefixlen; |
290 | 299 | ||
291 | diff_setup(&opt); | 300 | diff_setup(&opt); |
292 | opt.output_format = DIFF_FORMAT_CALLBACK; | 301 | opt.output_format = DIFF_FORMAT_CALLBACK; |
293 | opt.detect_rename = 1; | 302 | opt.detect_rename = 1; |
294 | opt.rename_limit = ctx.cfg.renamelimit; | 303 | opt.rename_limit = ctx.cfg.renamelimit; |
295 | DIFF_OPT_SET(&opt, RECURSIVE); | 304 | DIFF_OPT_SET(&opt, RECURSIVE); |
296 | opt.format_callback = cgit_diff_tree_cb; | 305 | opt.format_callback = cgit_diff_tree_cb; |
297 | opt.format_callback_data = fn; | 306 | opt.format_callback_data = fn; |
298 | if (prefix) { | 307 | if (prefix) { |
299 | opt.nr_paths = 1; | 308 | opt.nr_paths = 1; |
300 | opt.paths = &prefix; | 309 | opt.paths = &prefix; |
301 | prefixlen = strlen(prefix); | 310 | prefixlen = strlen(prefix); |
302 | opt.pathlens = &prefixlen; | 311 | opt.pathlens = &prefixlen; |
303 | } | 312 | } |
304 | diff_setup_done(&opt); | 313 | diff_setup_done(&opt); |
305 | 314 | ||
306 | if (old_sha1 && !is_null_sha1(old_sha1)) | 315 | if (old_sha1 && !is_null_sha1(old_sha1)) |
307 | ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); | 316 | ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); |
308 | else | 317 | else |
309 | ret = diff_root_tree_sha1(new_sha1, "", &opt); | 318 | ret = diff_root_tree_sha1(new_sha1, "", &opt); |
310 | diffcore_std(&opt); | 319 | diffcore_std(&opt); |
311 | diff_flush(&opt); | 320 | diff_flush(&opt); |
312 | } | 321 | } |
313 | 322 | ||
314 | void cgit_diff_commit(struct commit *commit, filepair_fn fn) | 323 | void cgit_diff_commit(struct commit *commit, filepair_fn fn) |
315 | { | 324 | { |
316 | unsigned char *old_sha1 = NULL; | 325 | unsigned char *old_sha1 = NULL; |
317 | 326 | ||
318 | if (commit->parents) | 327 | if (commit->parents) |
@@ -1,180 +1,195 @@ | |||
1 | /* ui-diff.c: show diff between two blobs | 1 | /* ui-diff.c: show diff between two blobs |
2 | * | 2 | * |
3 | * Copyright (C) 2006 Lars Hjemli | 3 | * Copyright (C) 2006 Lars Hjemli |
4 | * | 4 | * |
5 | * Licensed under GNU General Public License v2 | 5 | * Licensed under GNU General Public License v2 |
6 | * (see COPYING for full license text) | 6 | * (see COPYING for full license text) |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #include "cgit.h" | 9 | #include "cgit.h" |
10 | #include "html.h" | 10 | #include "html.h" |
11 | #include "ui-shared.h" | 11 | #include "ui-shared.h" |
12 | 12 | ||
13 | unsigned char old_rev_sha1[20]; | 13 | unsigned char old_rev_sha1[20]; |
14 | unsigned char new_rev_sha1[20]; | 14 | unsigned char new_rev_sha1[20]; |
15 | 15 | ||
16 | static int files, slots; | 16 | static int files, slots; |
17 | static int total_adds, total_rems, max_changes; | 17 | static int total_adds, total_rems, max_changes; |
18 | static int lines_added, lines_removed; | 18 | static int lines_added, lines_removed; |
19 | 19 | ||
20 | static struct fileinfo { | 20 | static struct fileinfo { |
21 | char status; | 21 | char status; |
22 | unsigned char old_sha1[20]; | 22 | unsigned char old_sha1[20]; |
23 | unsigned char new_sha1[20]; | 23 | unsigned char new_sha1[20]; |
24 | unsigned short old_mode; | 24 | unsigned short old_mode; |
25 | unsigned short new_mode; | 25 | unsigned short new_mode; |
26 | char *old_path; | 26 | char *old_path; |
27 | char *new_path; | 27 | char *new_path; |
28 | unsigned int added; | 28 | unsigned int added; |
29 | unsigned int removed; | 29 | unsigned int removed; |
30 | unsigned long old_size; | ||
31 | unsigned long new_size; | ||
32 | int binary:1; | ||
30 | } *items; | 33 | } *items; |
31 | 34 | ||
32 | 35 | ||
33 | static void print_fileinfo(struct fileinfo *info) | 36 | static void print_fileinfo(struct fileinfo *info) |
34 | { | 37 | { |
35 | char *class; | 38 | char *class; |
36 | 39 | ||
37 | switch (info->status) { | 40 | switch (info->status) { |
38 | case DIFF_STATUS_ADDED: | 41 | case DIFF_STATUS_ADDED: |
39 | class = "add"; | 42 | class = "add"; |
40 | break; | 43 | break; |
41 | case DIFF_STATUS_COPIED: | 44 | case DIFF_STATUS_COPIED: |
42 | class = "cpy"; | 45 | class = "cpy"; |
43 | break; | 46 | break; |
44 | case DIFF_STATUS_DELETED: | 47 | case DIFF_STATUS_DELETED: |
45 | class = "del"; | 48 | class = "del"; |
46 | break; | 49 | break; |
47 | case DIFF_STATUS_MODIFIED: | 50 | case DIFF_STATUS_MODIFIED: |
48 | class = "upd"; | 51 | class = "upd"; |
49 | break; | 52 | break; |
50 | case DIFF_STATUS_RENAMED: | 53 | case DIFF_STATUS_RENAMED: |
51 | class = "mov"; | 54 | class = "mov"; |
52 | break; | 55 | break; |
53 | case DIFF_STATUS_TYPE_CHANGED: | 56 | case DIFF_STATUS_TYPE_CHANGED: |
54 | class = "typ"; | 57 | class = "typ"; |
55 | break; | 58 | break; |
56 | case DIFF_STATUS_UNKNOWN: | 59 | case DIFF_STATUS_UNKNOWN: |
57 | class = "unk"; | 60 | class = "unk"; |
58 | break; | 61 | break; |
59 | case DIFF_STATUS_UNMERGED: | 62 | case DIFF_STATUS_UNMERGED: |
60 | class = "stg"; | 63 | class = "stg"; |
61 | break; | 64 | break; |
62 | default: | 65 | default: |
63 | die("bug: unhandled diff status %c", info->status); | 66 | die("bug: unhandled diff status %c", info->status); |
64 | } | 67 | } |
65 | 68 | ||
66 | html("<tr>"); | 69 | html("<tr>"); |
67 | htmlf("<td class='mode'>"); | 70 | htmlf("<td class='mode'>"); |
68 | if (is_null_sha1(info->new_sha1)) { | 71 | if (is_null_sha1(info->new_sha1)) { |
69 | cgit_print_filemode(info->old_mode); | 72 | cgit_print_filemode(info->old_mode); |
70 | } else { | 73 | } else { |
71 | cgit_print_filemode(info->new_mode); | 74 | cgit_print_filemode(info->new_mode); |
72 | } | 75 | } |
73 | 76 | ||
74 | if (info->old_mode != info->new_mode && | 77 | if (info->old_mode != info->new_mode && |
75 | !is_null_sha1(info->old_sha1) && | 78 | !is_null_sha1(info->old_sha1) && |
76 | !is_null_sha1(info->new_sha1)) { | 79 | !is_null_sha1(info->new_sha1)) { |
77 | html("<span class='modechange'>["); | 80 | html("<span class='modechange'>["); |
78 | cgit_print_filemode(info->old_mode); | 81 | cgit_print_filemode(info->old_mode); |
79 | html("]</span>"); | 82 | html("]</span>"); |
80 | } | 83 | } |
81 | htmlf("</td><td class='%s'>", class); | 84 | htmlf("</td><td class='%s'>", class); |
82 | cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.sha1, | 85 | cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.sha1, |
83 | ctx.qry.sha2, info->new_path); | 86 | ctx.qry.sha2, info->new_path); |
84 | if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED) | 87 | if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED) |
85 | htmlf(" (%s from %s)", | 88 | htmlf(" (%s from %s)", |
86 | info->status == DIFF_STATUS_COPIED ? "copied" : "renamed", | 89 | info->status == DIFF_STATUS_COPIED ? "copied" : "renamed", |
87 | info->old_path); | 90 | info->old_path); |
88 | html("</td><td class='right'>"); | 91 | html("</td><td class='right'>"); |
92 | if (info->binary) { | ||
93 | htmlf("bin</td><td class='graph'>%d -> %d bytes", | ||
94 | info->old_size, info->new_size); | ||
95 | return; | ||
96 | } | ||
89 | htmlf("%d", info->added + info->removed); | 97 | htmlf("%d", info->added + info->removed); |
90 | html("</td><td class='graph'>"); | 98 | html("</td><td class='graph'>"); |
91 | htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes)); | 99 | htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes)); |
92 | htmlf("<td class='add' style='width: %.1f%%;'/>", | 100 | htmlf("<td class='add' style='width: %.1f%%;'/>", |
93 | info->added * 100.0 / max_changes); | 101 | info->added * 100.0 / max_changes); |
94 | htmlf("<td class='rem' style='width: %.1f%%;'/>", | 102 | htmlf("<td class='rem' style='width: %.1f%%;'/>", |
95 | info->removed * 100.0 / max_changes); | 103 | info->removed * 100.0 / max_changes); |
96 | htmlf("<td class='none' style='width: %.1f%%;'/>", | 104 | htmlf("<td class='none' style='width: %.1f%%;'/>", |
97 | (max_changes - info->removed - info->added) * 100.0 / max_changes); | 105 | (max_changes - info->removed - info->added) * 100.0 / max_changes); |
98 | html("</tr></table></td></tr>\n"); | 106 | html("</tr></table></td></tr>\n"); |
99 | } | 107 | } |
100 | 108 | ||
101 | static void count_diff_lines(char *line, int len) | 109 | static void count_diff_lines(char *line, int len) |
102 | { | 110 | { |
103 | if (line && (len > 0)) { | 111 | if (line && (len > 0)) { |
104 | if (line[0] == '+') | 112 | if (line[0] == '+') |
105 | lines_added++; | 113 | lines_added++; |
106 | else if (line[0] == '-') | 114 | else if (line[0] == '-') |
107 | lines_removed++; | 115 | lines_removed++; |
108 | } | 116 | } |
109 | } | 117 | } |
110 | 118 | ||
111 | static void inspect_filepair(struct diff_filepair *pair) | 119 | static void inspect_filepair(struct diff_filepair *pair) |
112 | { | 120 | { |
121 | int binary = 0; | ||
122 | unsigned long old_size = 0; | ||
123 | unsigned long new_size = 0; | ||
113 | files++; | 124 | files++; |
114 | lines_added = 0; | 125 | lines_added = 0; |
115 | lines_removed = 0; | 126 | lines_removed = 0; |
116 | cgit_diff_files(pair->one->sha1, pair->two->sha1, count_diff_lines); | 127 | cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, &new_size, |
128 | &binary, count_diff_lines); | ||
117 | if (files >= slots) { | 129 | if (files >= slots) { |
118 | if (slots == 0) | 130 | if (slots == 0) |
119 | slots = 4; | 131 | slots = 4; |
120 | else | 132 | else |
121 | slots = slots * 2; | 133 | slots = slots * 2; |
122 | items = xrealloc(items, slots * sizeof(struct fileinfo)); | 134 | items = xrealloc(items, slots * sizeof(struct fileinfo)); |
123 | } | 135 | } |
124 | items[files-1].status = pair->status; | 136 | items[files-1].status = pair->status; |
125 | hashcpy(items[files-1].old_sha1, pair->one->sha1); | 137 | hashcpy(items[files-1].old_sha1, pair->one->sha1); |
126 | hashcpy(items[files-1].new_sha1, pair->two->sha1); | 138 | hashcpy(items[files-1].new_sha1, pair->two->sha1); |
127 | items[files-1].old_mode = pair->one->mode; | 139 | items[files-1].old_mode = pair->one->mode; |
128 | items[files-1].new_mode = pair->two->mode; | 140 | items[files-1].new_mode = pair->two->mode; |
129 | items[files-1].old_path = xstrdup(pair->one->path); | 141 | items[files-1].old_path = xstrdup(pair->one->path); |
130 | items[files-1].new_path = xstrdup(pair->two->path); | 142 | items[files-1].new_path = xstrdup(pair->two->path); |
131 | items[files-1].added = lines_added; | 143 | items[files-1].added = lines_added; |
132 | items[files-1].removed = lines_removed; | 144 | items[files-1].removed = lines_removed; |
145 | items[files-1].old_size = old_size; | ||
146 | items[files-1].new_size = new_size; | ||
147 | items[files-1].binary = binary; | ||
133 | if (lines_added + lines_removed > max_changes) | 148 | if (lines_added + lines_removed > max_changes) |
134 | max_changes = lines_added + lines_removed; | 149 | max_changes = lines_added + lines_removed; |
135 | total_adds += lines_added; | 150 | total_adds += lines_added; |
136 | total_rems += lines_removed; | 151 | total_rems += lines_removed; |
137 | } | 152 | } |
138 | 153 | ||
139 | void cgit_print_diffstat(const unsigned char *old_sha1, | 154 | void cgit_print_diffstat(const unsigned char *old_sha1, |
140 | const unsigned char *new_sha1) | 155 | const unsigned char *new_sha1) |
141 | { | 156 | { |
142 | int i; | 157 | int i; |
143 | 158 | ||
144 | html("<div class='diffstat-header'>"); | 159 | html("<div class='diffstat-header'>"); |
145 | cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.sha1, | 160 | cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.sha1, |
146 | ctx.qry.sha2, NULL); | 161 | ctx.qry.sha2, NULL); |
147 | html("</div>"); | 162 | html("</div>"); |
148 | html("<table summary='diffstat' class='diffstat'>"); | 163 | html("<table summary='diffstat' class='diffstat'>"); |
149 | max_changes = 0; | 164 | max_changes = 0; |
150 | cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, NULL); | 165 | cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, NULL); |
151 | for(i = 0; i<files; i++) | 166 | for(i = 0; i<files; i++) |
152 | print_fileinfo(&items[i]); | 167 | print_fileinfo(&items[i]); |
153 | html("</table>"); | 168 | html("</table>"); |
154 | html("<div class='diffstat-summary'>"); | 169 | html("<div class='diffstat-summary'>"); |
155 | htmlf("%d files changed, %d insertions, %d deletions", | 170 | htmlf("%d files changed, %d insertions, %d deletions", |
156 | files, total_adds, total_rems); | 171 | files, total_adds, total_rems); |
157 | html("</div>"); | 172 | html("</div>"); |
158 | } | 173 | } |
159 | 174 | ||
160 | 175 | ||
161 | /* | 176 | /* |
162 | * print a single line returned from xdiff | 177 | * print a single line returned from xdiff |
163 | */ | 178 | */ |
164 | static void print_line(char *line, int len) | 179 | static void print_line(char *line, int len) |
165 | { | 180 | { |
166 | char *class = "ctx"; | 181 | char *class = "ctx"; |
167 | char c = line[len-1]; | 182 | char c = line[len-1]; |
168 | 183 | ||
169 | if (line[0] == '+') | 184 | if (line[0] == '+') |
170 | class = "add"; | 185 | class = "add"; |
171 | else if (line[0] == '-') | 186 | else if (line[0] == '-') |
172 | class = "del"; | 187 | class = "del"; |
173 | else if (line[0] == '@') | 188 | else if (line[0] == '@') |
174 | class = "hunk"; | 189 | class = "hunk"; |
175 | 190 | ||
176 | htmlf("<div class='%s'>", class); | 191 | htmlf("<div class='%s'>", class); |
177 | line[len-1] = '\0'; | 192 | line[len-1] = '\0'; |
178 | html_txt(line); | 193 | html_txt(line); |
179 | html("</div>"); | 194 | html("</div>"); |
180 | line[len-1] = c; | 195 | line[len-1] = c; |
@@ -188,104 +203,111 @@ static void header(unsigned char *sha1, char *path1, int mode1, | |||
188 | 203 | ||
189 | subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); | 204 | subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); |
190 | html("<div class='head'>"); | 205 | html("<div class='head'>"); |
191 | html("diff --git a/"); | 206 | html("diff --git a/"); |
192 | html_txt(path1); | 207 | html_txt(path1); |
193 | html(" b/"); | 208 | html(" b/"); |
194 | html_txt(path2); | 209 | html_txt(path2); |
195 | 210 | ||
196 | if (is_null_sha1(sha1)) | 211 | if (is_null_sha1(sha1)) |
197 | path1 = "dev/null"; | 212 | path1 = "dev/null"; |
198 | if (is_null_sha1(sha2)) | 213 | if (is_null_sha1(sha2)) |
199 | path2 = "dev/null"; | 214 | path2 = "dev/null"; |
200 | 215 | ||
201 | if (mode1 == 0) | 216 | if (mode1 == 0) |
202 | htmlf("<br/>new file mode %.6o", mode2); | 217 | htmlf("<br/>new file mode %.6o", mode2); |
203 | 218 | ||
204 | if (mode2 == 0) | 219 | if (mode2 == 0) |
205 | htmlf("<br/>deleted file mode %.6o", mode1); | 220 | htmlf("<br/>deleted file mode %.6o", mode1); |
206 | 221 | ||
207 | if (!subproject) { | 222 | if (!subproject) { |
208 | abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); | 223 | abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); |
209 | abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); | 224 | abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); |
210 | htmlf("<br/>index %s..%s", abbrev1, abbrev2); | 225 | htmlf("<br/>index %s..%s", abbrev1, abbrev2); |
211 | free(abbrev1); | 226 | free(abbrev1); |
212 | free(abbrev2); | 227 | free(abbrev2); |
213 | if (mode1 != 0 && mode2 != 0) { | 228 | if (mode1 != 0 && mode2 != 0) { |
214 | htmlf(" %.6o", mode1); | 229 | htmlf(" %.6o", mode1); |
215 | if (mode2 != mode1) | 230 | if (mode2 != mode1) |
216 | htmlf("..%.6o", mode2); | 231 | htmlf("..%.6o", mode2); |
217 | } | 232 | } |
218 | html("<br/>--- a/"); | 233 | html("<br/>--- a/"); |
219 | if (mode1 != 0) | 234 | if (mode1 != 0) |
220 | cgit_tree_link(path1, NULL, NULL, ctx.qry.head, | 235 | cgit_tree_link(path1, NULL, NULL, ctx.qry.head, |
221 | sha1_to_hex(old_rev_sha1), path1); | 236 | sha1_to_hex(old_rev_sha1), path1); |
222 | else | 237 | else |
223 | html_txt(path1); | 238 | html_txt(path1); |
224 | html("<br/>+++ b/"); | 239 | html("<br/>+++ b/"); |
225 | if (mode2 != 0) | 240 | if (mode2 != 0) |
226 | cgit_tree_link(path2, NULL, NULL, ctx.qry.head, | 241 | cgit_tree_link(path2, NULL, NULL, ctx.qry.head, |
227 | sha1_to_hex(new_rev_sha1), path2); | 242 | sha1_to_hex(new_rev_sha1), path2); |
228 | else | 243 | else |
229 | html_txt(path2); | 244 | html_txt(path2); |
230 | } | 245 | } |
231 | html("</div>"); | 246 | html("</div>"); |
232 | } | 247 | } |
233 | 248 | ||
234 | static void filepair_cb(struct diff_filepair *pair) | 249 | static void filepair_cb(struct diff_filepair *pair) |
235 | { | 250 | { |
251 | unsigned long old_size = 0; | ||
252 | unsigned long new_size = 0; | ||
253 | int binary = 0; | ||
254 | |||
236 | header(pair->one->sha1, pair->one->path, pair->one->mode, | 255 | header(pair->one->sha1, pair->one->path, pair->one->mode, |
237 | pair->two->sha1, pair->two->path, pair->two->mode); | 256 | pair->two->sha1, pair->two->path, pair->two->mode); |
238 | if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { | 257 | if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { |
239 | if (S_ISGITLINK(pair->one->mode)) | 258 | if (S_ISGITLINK(pair->one->mode)) |
240 | print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); | 259 | print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); |
241 | if (S_ISGITLINK(pair->two->mode)) | 260 | if (S_ISGITLINK(pair->two->mode)) |
242 | print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); | 261 | print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); |
243 | return; | 262 | return; |
244 | } | 263 | } |
245 | if (cgit_diff_files(pair->one->sha1, pair->two->sha1, print_line)) | 264 | if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, |
265 | &new_size, &binary, print_line)) | ||
246 | cgit_print_error("Error running diff"); | 266 | cgit_print_error("Error running diff"); |
267 | if (binary) | ||
268 | html("Binary files differ"); | ||
247 | } | 269 | } |
248 | 270 | ||
249 | void cgit_print_diff(const char *new_rev, const char *old_rev, const char *prefix) | 271 | void cgit_print_diff(const char *new_rev, const char *old_rev, const char *prefix) |
250 | { | 272 | { |
251 | enum object_type type; | 273 | enum object_type type; |
252 | unsigned long size; | 274 | unsigned long size; |
253 | struct commit *commit, *commit2; | 275 | struct commit *commit, *commit2; |
254 | 276 | ||
255 | if (!new_rev) | 277 | if (!new_rev) |
256 | new_rev = ctx.qry.head; | 278 | new_rev = ctx.qry.head; |
257 | get_sha1(new_rev, new_rev_sha1); | 279 | get_sha1(new_rev, new_rev_sha1); |
258 | type = sha1_object_info(new_rev_sha1, &size); | 280 | type = sha1_object_info(new_rev_sha1, &size); |
259 | if (type == OBJ_BAD) { | 281 | if (type == OBJ_BAD) { |
260 | cgit_print_error(fmt("Bad object name: %s", new_rev)); | 282 | cgit_print_error(fmt("Bad object name: %s", new_rev)); |
261 | return; | 283 | return; |
262 | } | 284 | } |
263 | commit = lookup_commit_reference(new_rev_sha1); | 285 | commit = lookup_commit_reference(new_rev_sha1); |
264 | if (!commit || parse_commit(commit)) | 286 | if (!commit || parse_commit(commit)) |
265 | cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(new_rev_sha1))); | 287 | cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(new_rev_sha1))); |
266 | 288 | ||
267 | if (old_rev) | 289 | if (old_rev) |
268 | get_sha1(old_rev, old_rev_sha1); | 290 | get_sha1(old_rev, old_rev_sha1); |
269 | else if (commit->parents && commit->parents->item) | 291 | else if (commit->parents && commit->parents->item) |
270 | hashcpy(old_rev_sha1, commit->parents->item->object.sha1); | 292 | hashcpy(old_rev_sha1, commit->parents->item->object.sha1); |
271 | else | 293 | else |
272 | hashclr(old_rev_sha1); | 294 | hashclr(old_rev_sha1); |
273 | 295 | ||
274 | if (!is_null_sha1(old_rev_sha1)) { | 296 | if (!is_null_sha1(old_rev_sha1)) { |
275 | type = sha1_object_info(old_rev_sha1, &size); | 297 | type = sha1_object_info(old_rev_sha1, &size); |
276 | if (type == OBJ_BAD) { | 298 | if (type == OBJ_BAD) { |
277 | cgit_print_error(fmt("Bad object name: %s", sha1_to_hex(old_rev_sha1))); | 299 | cgit_print_error(fmt("Bad object name: %s", sha1_to_hex(old_rev_sha1))); |
278 | return; | 300 | return; |
279 | } | 301 | } |
280 | commit2 = lookup_commit_reference(old_rev_sha1); | 302 | commit2 = lookup_commit_reference(old_rev_sha1); |
281 | if (!commit2 || parse_commit(commit2)) | 303 | if (!commit2 || parse_commit(commit2)) |
282 | cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(old_rev_sha1))); | 304 | cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(old_rev_sha1))); |
283 | } | 305 | } |
284 | cgit_print_diffstat(old_rev_sha1, new_rev_sha1); | 306 | cgit_print_diffstat(old_rev_sha1, new_rev_sha1); |
285 | 307 | ||
286 | html("<table summary='diff' class='diff'>"); | 308 | html("<table summary='diff' class='diff'>"); |
287 | html("<tr><td>"); | 309 | html("<tr><td>"); |
288 | cgit_diff_tree(old_rev_sha1, new_rev_sha1, filepair_cb, prefix); | 310 | cgit_diff_tree(old_rev_sha1, new_rev_sha1, filepair_cb, prefix); |
289 | html("</td></tr>"); | 311 | html("</td></tr>"); |
290 | html("</table>"); | 312 | html("</table>"); |
291 | } | 313 | } |
@@ -1,79 +1,84 @@ | |||
1 | /* ui-log.c: functions for log output | 1 | /* ui-log.c: functions for log output |
2 | * | 2 | * |
3 | * Copyright (C) 2006 Lars Hjemli | 3 | * Copyright (C) 2006 Lars Hjemli |
4 | * | 4 | * |
5 | * Licensed under GNU General Public License v2 | 5 | * Licensed under GNU General Public License v2 |
6 | * (see COPYING for full license text) | 6 | * (see COPYING for full license text) |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #include "cgit.h" | 9 | #include "cgit.h" |
10 | #include "html.h" | 10 | #include "html.h" |
11 | #include "ui-shared.h" | 11 | #include "ui-shared.h" |
12 | 12 | ||
13 | int files, add_lines, rem_lines; | 13 | int files, add_lines, rem_lines; |
14 | 14 | ||
15 | void count_lines(char *line, int size) | 15 | void count_lines(char *line, int size) |
16 | { | 16 | { |
17 | if (size <= 0) | 17 | if (size <= 0) |
18 | return; | 18 | return; |
19 | 19 | ||
20 | if (line[0] == '+') | 20 | if (line[0] == '+') |
21 | add_lines++; | 21 | add_lines++; |
22 | 22 | ||
23 | else if (line[0] == '-') | 23 | else if (line[0] == '-') |
24 | rem_lines++; | 24 | rem_lines++; |
25 | } | 25 | } |
26 | 26 | ||
27 | void inspect_files(struct diff_filepair *pair) | 27 | void inspect_files(struct diff_filepair *pair) |
28 | { | 28 | { |
29 | unsigned long old_size = 0; | ||
30 | unsigned long new_size = 0; | ||
31 | int binary = 0; | ||
32 | |||
29 | files++; | 33 | files++; |
30 | if (ctx.repo->enable_log_linecount) | 34 | if (ctx.repo->enable_log_linecount) |
31 | cgit_diff_files(pair->one->sha1, pair->two->sha1, count_lines); | 35 | cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, |
36 | &new_size, &binary, count_lines); | ||
32 | } | 37 | } |
33 | 38 | ||
34 | void show_commit_decorations(struct commit *commit) | 39 | void show_commit_decorations(struct commit *commit) |
35 | { | 40 | { |
36 | struct name_decoration *deco; | 41 | struct name_decoration *deco; |
37 | static char buf[1024]; | 42 | static char buf[1024]; |
38 | 43 | ||
39 | buf[sizeof(buf) - 1] = 0; | 44 | buf[sizeof(buf) - 1] = 0; |
40 | deco = lookup_decoration(&name_decoration, &commit->object); | 45 | deco = lookup_decoration(&name_decoration, &commit->object); |
41 | while (deco) { | 46 | while (deco) { |
42 | if (!prefixcmp(deco->name, "refs/heads/")) { | 47 | if (!prefixcmp(deco->name, "refs/heads/")) { |
43 | strncpy(buf, deco->name + 11, sizeof(buf) - 1); | 48 | strncpy(buf, deco->name + 11, sizeof(buf) - 1); |
44 | cgit_log_link(buf, NULL, "branch-deco", buf, NULL, NULL, | 49 | cgit_log_link(buf, NULL, "branch-deco", buf, NULL, NULL, |
45 | 0, NULL, NULL, ctx.qry.showmsg); | 50 | 0, NULL, NULL, ctx.qry.showmsg); |
46 | } | 51 | } |
47 | else if (!prefixcmp(deco->name, "tag: refs/tags/")) { | 52 | else if (!prefixcmp(deco->name, "tag: refs/tags/")) { |
48 | strncpy(buf, deco->name + 15, sizeof(buf) - 1); | 53 | strncpy(buf, deco->name + 15, sizeof(buf) - 1); |
49 | cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf); | 54 | cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf); |
50 | } | 55 | } |
51 | else if (!prefixcmp(deco->name, "refs/remotes/")) { | 56 | else if (!prefixcmp(deco->name, "refs/remotes/")) { |
52 | strncpy(buf, deco->name + 13, sizeof(buf) - 1); | 57 | strncpy(buf, deco->name + 13, sizeof(buf) - 1); |
53 | cgit_log_link(buf, NULL, "remote-deco", NULL, | 58 | cgit_log_link(buf, NULL, "remote-deco", NULL, |
54 | sha1_to_hex(commit->object.sha1), NULL, | 59 | sha1_to_hex(commit->object.sha1), NULL, |
55 | 0, NULL, NULL, ctx.qry.showmsg); | 60 | 0, NULL, NULL, ctx.qry.showmsg); |
56 | } | 61 | } |
57 | else { | 62 | else { |
58 | strncpy(buf, deco->name, sizeof(buf) - 1); | 63 | strncpy(buf, deco->name, sizeof(buf) - 1); |
59 | cgit_commit_link(buf, NULL, "deco", ctx.qry.head, | 64 | cgit_commit_link(buf, NULL, "deco", ctx.qry.head, |
60 | sha1_to_hex(commit->object.sha1)); | 65 | sha1_to_hex(commit->object.sha1)); |
61 | } | 66 | } |
62 | deco = deco->next; | 67 | deco = deco->next; |
63 | } | 68 | } |
64 | } | 69 | } |
65 | 70 | ||
66 | void print_commit(struct commit *commit) | 71 | void print_commit(struct commit *commit) |
67 | { | 72 | { |
68 | struct commitinfo *info; | 73 | struct commitinfo *info; |
69 | char *tmp; | 74 | char *tmp; |
70 | int cols = 2; | 75 | int cols = 2; |
71 | 76 | ||
72 | info = cgit_parse_commit(commit); | 77 | info = cgit_parse_commit(commit); |
73 | htmlf("<tr%s><td>", | 78 | htmlf("<tr%s><td>", |
74 | ctx.qry.showmsg ? " class='logheader'" : ""); | 79 | ctx.qry.showmsg ? " class='logheader'" : ""); |
75 | tmp = fmt("id=%s", sha1_to_hex(commit->object.sha1)); | 80 | tmp = fmt("id=%s", sha1_to_hex(commit->object.sha1)); |
76 | tmp = cgit_pageurl(ctx.repo->url, "commit", tmp); | 81 | tmp = cgit_pageurl(ctx.repo->url, "commit", tmp); |
77 | html_link_open(tmp, NULL, NULL); | 82 | html_link_open(tmp, NULL, NULL); |
78 | cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE); | 83 | cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE); |
79 | html_link_close(); | 84 | html_link_close(); |
@@ -12,107 +12,114 @@ | |||
12 | 12 | ||
13 | static void print_line(char *line, int len) | 13 | static void print_line(char *line, int len) |
14 | { | 14 | { |
15 | char c = line[len-1]; | 15 | char c = line[len-1]; |
16 | 16 | ||
17 | line[len-1] = '\0'; | 17 | line[len-1] = '\0'; |
18 | htmlf("%s\n", line); | 18 | htmlf("%s\n", line); |
19 | line[len-1] = c; | 19 | line[len-1] = c; |
20 | } | 20 | } |
21 | 21 | ||
22 | static void header(unsigned char *sha1, char *path1, int mode1, | 22 | static void header(unsigned char *sha1, char *path1, int mode1, |
23 | unsigned char *sha2, char *path2, int mode2) | 23 | unsigned char *sha2, char *path2, int mode2) |
24 | { | 24 | { |
25 | char *abbrev1, *abbrev2; | 25 | char *abbrev1, *abbrev2; |
26 | int subproject; | 26 | int subproject; |
27 | 27 | ||
28 | subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); | 28 | subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); |
29 | htmlf("diff --git a/%s b/%s\n", path1, path2); | 29 | htmlf("diff --git a/%s b/%s\n", path1, path2); |
30 | 30 | ||
31 | if (is_null_sha1(sha1)) | 31 | if (is_null_sha1(sha1)) |
32 | path1 = "dev/null"; | 32 | path1 = "dev/null"; |
33 | if (is_null_sha1(sha2)) | 33 | if (is_null_sha1(sha2)) |
34 | path2 = "dev/null"; | 34 | path2 = "dev/null"; |
35 | 35 | ||
36 | if (mode1 == 0) | 36 | if (mode1 == 0) |
37 | htmlf("new file mode %.6o\n", mode2); | 37 | htmlf("new file mode %.6o\n", mode2); |
38 | 38 | ||
39 | if (mode2 == 0) | 39 | if (mode2 == 0) |
40 | htmlf("deleted file mode %.6o\n", mode1); | 40 | htmlf("deleted file mode %.6o\n", mode1); |
41 | 41 | ||
42 | if (!subproject) { | 42 | if (!subproject) { |
43 | abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); | 43 | abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); |
44 | abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); | 44 | abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); |
45 | htmlf("index %s..%s", abbrev1, abbrev2); | 45 | htmlf("index %s..%s", abbrev1, abbrev2); |
46 | free(abbrev1); | 46 | free(abbrev1); |
47 | free(abbrev2); | 47 | free(abbrev2); |
48 | if (mode1 != 0 && mode2 != 0) { | 48 | if (mode1 != 0 && mode2 != 0) { |
49 | htmlf(" %.6o", mode1); | 49 | htmlf(" %.6o", mode1); |
50 | if (mode2 != mode1) | 50 | if (mode2 != mode1) |
51 | htmlf("..%.6o", mode2); | 51 | htmlf("..%.6o", mode2); |
52 | } | 52 | } |
53 | htmlf("\n--- a/%s\n", path1); | 53 | htmlf("\n--- a/%s\n", path1); |
54 | htmlf("+++ b/%s\n", path2); | 54 | htmlf("+++ b/%s\n", path2); |
55 | } | 55 | } |
56 | } | 56 | } |
57 | 57 | ||
58 | static void filepair_cb(struct diff_filepair *pair) | 58 | static void filepair_cb(struct diff_filepair *pair) |
59 | { | 59 | { |
60 | unsigned long old_size = 0; | ||
61 | unsigned long new_size = 0; | ||
62 | int binary = 0; | ||
63 | |||
60 | header(pair->one->sha1, pair->one->path, pair->one->mode, | 64 | header(pair->one->sha1, pair->one->path, pair->one->mode, |
61 | pair->two->sha1, pair->two->path, pair->two->mode); | 65 | pair->two->sha1, pair->two->path, pair->two->mode); |
62 | if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { | 66 | if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { |
63 | if (S_ISGITLINK(pair->one->mode)) | 67 | if (S_ISGITLINK(pair->one->mode)) |
64 | print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); | 68 | print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); |
65 | if (S_ISGITLINK(pair->two->mode)) | 69 | if (S_ISGITLINK(pair->two->mode)) |
66 | print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); | 70 | print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); |
67 | return; | 71 | return; |
68 | } | 72 | } |
69 | if (cgit_diff_files(pair->one->sha1, pair->two->sha1, print_line)) | 73 | if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, |
74 | &new_size, &binary, print_line)) | ||
70 | html("Error running diff"); | 75 | html("Error running diff"); |
76 | if (binary) | ||
77 | html("Binary files differ\n"); | ||
71 | } | 78 | } |
72 | 79 | ||
73 | void cgit_print_patch(char *hex) | 80 | void cgit_print_patch(char *hex) |
74 | { | 81 | { |
75 | struct commit *commit; | 82 | struct commit *commit; |
76 | struct commitinfo *info; | 83 | struct commitinfo *info; |
77 | unsigned char sha1[20], old_sha1[20]; | 84 | unsigned char sha1[20], old_sha1[20]; |
78 | char *patchname; | 85 | char *patchname; |
79 | 86 | ||
80 | if (!hex) | 87 | if (!hex) |
81 | hex = ctx.qry.head; | 88 | hex = ctx.qry.head; |
82 | 89 | ||
83 | if (get_sha1(hex, sha1)) { | 90 | if (get_sha1(hex, sha1)) { |
84 | cgit_print_error(fmt("Bad object id: %s", hex)); | 91 | cgit_print_error(fmt("Bad object id: %s", hex)); |
85 | return; | 92 | return; |
86 | } | 93 | } |
87 | commit = lookup_commit_reference(sha1); | 94 | commit = lookup_commit_reference(sha1); |
88 | if (!commit) { | 95 | if (!commit) { |
89 | cgit_print_error(fmt("Bad commit reference: %s", hex)); | 96 | cgit_print_error(fmt("Bad commit reference: %s", hex)); |
90 | return; | 97 | return; |
91 | } | 98 | } |
92 | info = cgit_parse_commit(commit); | 99 | info = cgit_parse_commit(commit); |
93 | 100 | ||
94 | if (commit->parents && commit->parents->item) | 101 | if (commit->parents && commit->parents->item) |
95 | hashcpy(old_sha1, commit->parents->item->object.sha1); | 102 | hashcpy(old_sha1, commit->parents->item->object.sha1); |
96 | else | 103 | else |
97 | hashclr(old_sha1); | 104 | hashclr(old_sha1); |
98 | 105 | ||
99 | patchname = fmt("%s.patch", sha1_to_hex(sha1)); | 106 | patchname = fmt("%s.patch", sha1_to_hex(sha1)); |
100 | ctx.page.mimetype = "text/plain"; | 107 | ctx.page.mimetype = "text/plain"; |
101 | ctx.page.filename = patchname; | 108 | ctx.page.filename = patchname; |
102 | cgit_print_http_headers(&ctx); | 109 | cgit_print_http_headers(&ctx); |
103 | htmlf("From %s Mon Sep 17 00:00:00 2001\n", sha1_to_hex(sha1)); | 110 | htmlf("From %s Mon Sep 17 00:00:00 2001\n", sha1_to_hex(sha1)); |
104 | htmlf("From: %s %s\n", info->author, info->author_email); | 111 | htmlf("From: %s %s\n", info->author, info->author_email); |
105 | html("Date: "); | 112 | html("Date: "); |
106 | cgit_print_date(info->author_date, "%a, %d %b %Y %H:%M:%S %z%n", ctx.cfg.local_time); | 113 | cgit_print_date(info->author_date, "%a, %d %b %Y %H:%M:%S %z%n", ctx.cfg.local_time); |
107 | htmlf("Subject: %s\n\n", info->subject); | 114 | htmlf("Subject: %s\n\n", info->subject); |
108 | if (info->msg && *info->msg) { | 115 | if (info->msg && *info->msg) { |
109 | htmlf("%s", info->msg); | 116 | htmlf("%s", info->msg); |
110 | if (info->msg[strlen(info->msg) - 1] != '\n') | 117 | if (info->msg[strlen(info->msg) - 1] != '\n') |
111 | html("\n"); | 118 | html("\n"); |
112 | } | 119 | } |
113 | html("---\n"); | 120 | html("---\n"); |
114 | cgit_diff_tree(old_sha1, sha1, filepair_cb, NULL); | 121 | cgit_diff_tree(old_sha1, sha1, filepair_cb, NULL); |
115 | html("--\n"); | 122 | html("--\n"); |
116 | htmlf("cgit %s\n", CGIT_VERSION); | 123 | htmlf("cgit %s\n", CGIT_VERSION); |
117 | cgit_free_commitinfo(info); | 124 | cgit_free_commitinfo(info); |
118 | } | 125 | } |