|
diff --git a/cgit.h b/cgit.h index 4fe94c6..8b0defa 100644 --- a/ cgit.h+++ b/ cgit.h |
|
@@ -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 */ |
|
|
diff --git a/shared.c b/shared.c index 578a544..dbb84d8 100644 --- a/ shared.c+++ b/ shared.c |
|
@@ -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) |
|
|
diff --git a/ui-diff.c b/ui-diff.c index 878496d..2196745 100644 --- a/ ui-diff.c+++ b/ ui-diff.c |
|
@@ -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 | } |
|
|
diff --git a/ui-log.c b/ui-log.c index 3202848..ba2ab03 100644 --- a/ ui-log.c+++ b/ ui-log.c |
|
@@ -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 | } |
|