4 * Copyright (c) 2006, 2014 by its authors
5 * See COPYING for licensing conditions
8 #include "git-compat-util.h"
14 #include "repository.h"
19 #include "string-list.h"
21 #include "parse-options.h"
22 #include "prio-queue.h"
25 #include "line-range.h"
29 #include "object-store.h"
34 static char blame_usage
[] = N_("git blame [<options>] [<rev-opts>] [<rev>] [--] <file>");
35 static char annotate_usage
[] = N_("git annotate [<options>] [<rev-opts>] [<rev>] [--] <file>");
37 static const char *blame_opt_usage
[] = {
40 N_("<rev-opts> are documented in git-rev-list(1)"),
44 static const char *annotate_opt_usage
[] = {
47 N_("<rev-opts> are documented in git-rev-list(1)"),
51 static int longest_file
;
52 static int longest_author
;
53 static int max_orig_digits
;
54 static int max_digits
;
55 static int max_score_digits
;
58 static int blank_boundary
;
59 static int incremental
;
61 static int abbrev
= -1;
62 static int no_whole_file_rename
;
63 static int show_progress
;
64 static char repeated_meta_color
[COLOR_MAXLEN
];
65 static int coloring_mode
;
66 static struct string_list ignore_revs_file_list
= STRING_LIST_INIT_NODUP
;
67 static int mark_unblamable_lines
;
68 static int mark_ignored_lines
;
70 static struct date_mode blame_date_mode
= { DATE_ISO8601
};
71 static size_t blame_date_width
;
73 static struct string_list mailmap
= STRING_LIST_INIT_NODUP
;
79 static unsigned blame_move_score
;
80 static unsigned blame_copy_score
;
82 /* Remember to update object flag allocation in object.h */
83 #define METAINFO_SHOWN (1u<<12)
84 #define MORE_THAN_ONE_PATH (1u<<13)
86 struct progress_info
{
87 struct progress
*progress
;
91 static const char *nth_line_cb(void *data
, long lno
)
93 return blame_nth_line((struct blame_scoreboard
*)data
, lno
);
97 * Information on commits, used for output.
100 struct strbuf author
;
101 struct strbuf author_mail
;
102 timestamp_t author_time
;
103 struct strbuf author_tz
;
105 /* filled only when asked for details */
106 struct strbuf committer
;
107 struct strbuf committer_mail
;
108 timestamp_t committer_time
;
109 struct strbuf committer_tz
;
111 struct strbuf summary
;
114 #define COMMIT_INFO_INIT { \
115 .author = STRBUF_INIT, \
116 .author_mail = STRBUF_INIT, \
117 .author_tz = STRBUF_INIT, \
118 .committer = STRBUF_INIT, \
119 .committer_mail = STRBUF_INIT, \
120 .committer_tz = STRBUF_INIT, \
121 .summary = STRBUF_INIT, \
125 * Parse author/committer line in the commit object buffer
127 static void get_ac_line(const char *inbuf
, const char *what
,
128 struct strbuf
*name
, struct strbuf
*mail
,
129 timestamp_t
*time
, struct strbuf
*tz
)
131 struct ident_split ident
;
132 size_t len
, maillen
, namelen
;
134 const char *namebuf
, *mailbuf
;
136 tmp
= strstr(inbuf
, what
);
140 endp
= strchr(tmp
, '\n');
146 if (split_ident_line(&ident
, tmp
, len
)) {
150 strbuf_addstr(name
, tmp
);
151 strbuf_addstr(mail
, tmp
);
152 strbuf_addstr(tz
, tmp
);
157 namelen
= ident
.name_end
- ident
.name_begin
;
158 namebuf
= ident
.name_begin
;
160 maillen
= ident
.mail_end
- ident
.mail_begin
;
161 mailbuf
= ident
.mail_begin
;
163 if (ident
.date_begin
&& ident
.date_end
)
164 *time
= strtoul(ident
.date_begin
, NULL
, 10);
168 if (ident
.tz_begin
&& ident
.tz_end
)
169 strbuf_add(tz
, ident
.tz_begin
, ident
.tz_end
- ident
.tz_begin
);
171 strbuf_addstr(tz
, "(unknown)");
174 * Now, convert both name and e-mail using mailmap
176 map_user(&mailmap
, &mailbuf
, &maillen
,
179 strbuf_addf(mail
, "<%.*s>", (int)maillen
, mailbuf
);
180 strbuf_add(name
, namebuf
, namelen
);
183 static void commit_info_destroy(struct commit_info
*ci
)
186 strbuf_release(&ci
->author
);
187 strbuf_release(&ci
->author_mail
);
188 strbuf_release(&ci
->author_tz
);
189 strbuf_release(&ci
->committer
);
190 strbuf_release(&ci
->committer_mail
);
191 strbuf_release(&ci
->committer_tz
);
192 strbuf_release(&ci
->summary
);
195 static void get_commit_info(struct commit
*commit
,
196 struct commit_info
*ret
,
200 const char *subject
, *encoding
;
203 encoding
= get_log_output_encoding();
204 message
= logmsg_reencode(commit
, NULL
, encoding
);
205 get_ac_line(message
, "\nauthor ",
206 &ret
->author
, &ret
->author_mail
,
207 &ret
->author_time
, &ret
->author_tz
);
210 unuse_commit_buffer(commit
, message
);
214 get_ac_line(message
, "\ncommitter ",
215 &ret
->committer
, &ret
->committer_mail
,
216 &ret
->committer_time
, &ret
->committer_tz
);
218 len
= find_commit_subject(message
, &subject
);
220 strbuf_add(&ret
->summary
, subject
, len
);
222 strbuf_addf(&ret
->summary
, "(%s)", oid_to_hex(&commit
->object
.oid
));
224 unuse_commit_buffer(commit
, message
);
228 * Write out any suspect information which depends on the path. This must be
229 * handled separately from emit_one_suspect_detail(), because a given commit
230 * may have changes in multiple paths. So this needs to appear each time
231 * we mention a new group.
233 * To allow LF and other nonportable characters in pathnames,
234 * they are c-style quoted as needed.
236 static void write_filename_info(struct blame_origin
*suspect
)
238 if (suspect
->previous
) {
239 struct blame_origin
*prev
= suspect
->previous
;
240 printf("previous %s ", oid_to_hex(&prev
->commit
->object
.oid
));
241 write_name_quoted(prev
->path
, stdout
, '\n');
244 write_name_quoted(suspect
->path
, stdout
, '\n');
248 * Porcelain/Incremental format wants to show a lot of details per
249 * commit. Instead of repeating this every line, emit it only once,
250 * the first time each commit appears in the output (unless the
251 * user has specifically asked for us to repeat).
253 static int emit_one_suspect_detail(struct blame_origin
*suspect
, int repeat
)
255 struct commit_info ci
= COMMIT_INFO_INIT
;
257 if (!repeat
&& (suspect
->commit
->object
.flags
& METAINFO_SHOWN
))
260 suspect
->commit
->object
.flags
|= METAINFO_SHOWN
;
261 get_commit_info(suspect
->commit
, &ci
, 1);
262 printf("author %s\n", ci
.author
.buf
);
263 printf("author-mail %s\n", ci
.author_mail
.buf
);
264 printf("author-time %"PRItime
"\n", ci
.author_time
);
265 printf("author-tz %s\n", ci
.author_tz
.buf
);
266 printf("committer %s\n", ci
.committer
.buf
);
267 printf("committer-mail %s\n", ci
.committer_mail
.buf
);
268 printf("committer-time %"PRItime
"\n", ci
.committer_time
);
269 printf("committer-tz %s\n", ci
.committer_tz
.buf
);
270 printf("summary %s\n", ci
.summary
.buf
);
271 if (suspect
->commit
->object
.flags
& UNINTERESTING
)
272 printf("boundary\n");
274 commit_info_destroy(&ci
);
280 * The blame_entry is found to be guilty for the range.
281 * Show it in incremental output.
283 static void found_guilty_entry(struct blame_entry
*ent
, void *data
)
285 struct progress_info
*pi
= (struct progress_info
*)data
;
288 struct blame_origin
*suspect
= ent
->suspect
;
290 printf("%s %d %d %d\n",
291 oid_to_hex(&suspect
->commit
->object
.oid
),
292 ent
->s_lno
+ 1, ent
->lno
+ 1, ent
->num_lines
);
293 emit_one_suspect_detail(suspect
, 0);
294 write_filename_info(suspect
);
295 maybe_flush_or_die(stdout
, "stdout");
297 pi
->blamed_lines
+= ent
->num_lines
;
298 display_progress(pi
->progress
, pi
->blamed_lines
);
301 static const char *format_time(timestamp_t time
, const char *tz_str
,
304 static struct strbuf time_buf
= STRBUF_INIT
;
306 strbuf_reset(&time_buf
);
308 strbuf_addf(&time_buf
, "%"PRItime
" %s", time
, tz_str
);
311 const char *time_str
;
315 time_str
= show_date(time
, tz
, &blame_date_mode
);
316 strbuf_addstr(&time_buf
, time_str
);
318 * Add space paddings to time_buf to display a fixed width
319 * string, and use time_width for display width calibration.
321 for (time_width
= utf8_strwidth(time_str
);
322 time_width
< blame_date_width
;
324 strbuf_addch(&time_buf
, ' ');
329 #define OUTPUT_ANNOTATE_COMPAT (1U<<0)
330 #define OUTPUT_LONG_OBJECT_NAME (1U<<1)
331 #define OUTPUT_RAW_TIMESTAMP (1U<<2)
332 #define OUTPUT_PORCELAIN (1U<<3)
333 #define OUTPUT_SHOW_NAME (1U<<4)
334 #define OUTPUT_SHOW_NUMBER (1U<<5)
335 #define OUTPUT_SHOW_SCORE (1U<<6)
336 #define OUTPUT_NO_AUTHOR (1U<<7)
337 #define OUTPUT_SHOW_EMAIL (1U<<8)
338 #define OUTPUT_LINE_PORCELAIN (1U<<9)
339 #define OUTPUT_COLOR_LINE (1U<<10)
340 #define OUTPUT_SHOW_AGE_WITH_COLOR (1U<<11)
342 static void emit_porcelain_details(struct blame_origin
*suspect
, int repeat
)
344 if (emit_one_suspect_detail(suspect
, repeat
) ||
345 (suspect
->commit
->object
.flags
& MORE_THAN_ONE_PATH
))
346 write_filename_info(suspect
);
349 static void emit_porcelain(struct blame_scoreboard
*sb
, struct blame_entry
*ent
,
352 int repeat
= opt
& OUTPUT_LINE_PORCELAIN
;
355 struct blame_origin
*suspect
= ent
->suspect
;
356 char hex
[GIT_MAX_HEXSZ
+ 1];
358 oid_to_hex_r(hex
, &suspect
->commit
->object
.oid
);
359 printf("%s %d %d %d\n",
364 emit_porcelain_details(suspect
, repeat
);
366 cp
= blame_nth_line(sb
, ent
->lno
);
367 for (cnt
= 0; cnt
< ent
->num_lines
; cnt
++) {
370 printf("%s %d %d\n", hex
,
371 ent
->s_lno
+ 1 + cnt
,
374 emit_porcelain_details(suspect
, 1);
380 } while (ch
!= '\n' &&
381 cp
< sb
->final_buf
+ sb
->final_buf_size
);
384 if (sb
->final_buf_size
&& cp
[-1] != '\n')
388 static struct color_field
{
390 char col
[COLOR_MAXLEN
];
392 static int colorfield_nr
, colorfield_alloc
;
394 static void parse_color_fields(const char *s
)
396 struct string_list l
= STRING_LIST_INIT_DUP
;
397 struct string_list_item
*item
;
398 enum { EXPECT_DATE
, EXPECT_COLOR
} next
= EXPECT_COLOR
;
402 /* Ideally this would be stripped and split at the same time? */
403 string_list_split(&l
, s
, ',', -1);
404 ALLOC_GROW(colorfield
, colorfield_nr
+ 1, colorfield_alloc
);
406 for_each_string_list_item(item
, &l
) {
409 colorfield
[colorfield_nr
].hop
= approxidate(item
->string
);
412 ALLOC_GROW(colorfield
, colorfield_nr
+ 1, colorfield_alloc
);
415 if (color_parse(item
->string
, colorfield
[colorfield_nr
].col
))
416 die(_("expecting a color: %s"), item
->string
);
422 if (next
== EXPECT_COLOR
)
423 die(_("must end with a color"));
425 colorfield
[colorfield_nr
].hop
= TIME_MAX
;
426 string_list_clear(&l
, 0);
429 static void setup_default_color_by_age(void)
431 parse_color_fields("blue,12 month ago,white,1 month ago,red");
434 static void determine_line_heat(struct commit_info
*ci
, const char **dest_color
)
438 while (i
< colorfield_nr
&& ci
->author_time
> colorfield
[i
].hop
)
441 *dest_color
= colorfield
[i
].col
;
444 static void emit_other(struct blame_scoreboard
*sb
, struct blame_entry
*ent
, int opt
)
448 struct blame_origin
*suspect
= ent
->suspect
;
449 struct commit_info ci
= COMMIT_INFO_INIT
;
450 char hex
[GIT_MAX_HEXSZ
+ 1];
451 int show_raw_time
= !!(opt
& OUTPUT_RAW_TIMESTAMP
);
452 const char *default_color
= NULL
, *color
= NULL
, *reset
= NULL
;
454 get_commit_info(suspect
->commit
, &ci
, 1);
455 oid_to_hex_r(hex
, &suspect
->commit
->object
.oid
);
457 cp
= blame_nth_line(sb
, ent
->lno
);
459 if (opt
& OUTPUT_SHOW_AGE_WITH_COLOR
) {
460 determine_line_heat(&ci
, &default_color
);
461 color
= default_color
;
462 reset
= GIT_COLOR_RESET
;
465 for (cnt
= 0; cnt
< ent
->num_lines
; cnt
++) {
467 int length
= (opt
& OUTPUT_LONG_OBJECT_NAME
) ? the_hash_algo
->hexsz
: abbrev
;
469 if (opt
& OUTPUT_COLOR_LINE
) {
471 color
= repeated_meta_color
;
472 reset
= GIT_COLOR_RESET
;
474 color
= default_color
? default_color
: NULL
;
475 reset
= default_color
? GIT_COLOR_RESET
: NULL
;
479 fputs(color
, stdout
);
481 if (suspect
->commit
->object
.flags
& UNINTERESTING
) {
483 memset(hex
, ' ', length
);
484 else if (!(opt
& OUTPUT_ANNOTATE_COMPAT
)) {
490 if (mark_unblamable_lines
&& ent
->unblamable
) {
494 if (mark_ignored_lines
&& ent
->ignored
) {
498 printf("%.*s", length
, hex
);
499 if (opt
& OUTPUT_ANNOTATE_COMPAT
) {
501 if (opt
& OUTPUT_SHOW_EMAIL
)
502 name
= ci
.author_mail
.buf
;
504 name
= ci
.author
.buf
;
505 printf("\t(%10s\t%10s\t%d)", name
,
506 format_time(ci
.author_time
, ci
.author_tz
.buf
,
510 if (opt
& OUTPUT_SHOW_SCORE
)
512 max_score_digits
, ent
->score
,
513 ent
->suspect
->refcnt
);
514 if (opt
& OUTPUT_SHOW_NAME
)
515 printf(" %-*.*s", longest_file
, longest_file
,
517 if (opt
& OUTPUT_SHOW_NUMBER
)
518 printf(" %*d", max_orig_digits
,
519 ent
->s_lno
+ 1 + cnt
);
521 if (!(opt
& OUTPUT_NO_AUTHOR
)) {
524 if (opt
& OUTPUT_SHOW_EMAIL
)
525 name
= ci
.author_mail
.buf
;
527 name
= ci
.author
.buf
;
528 pad
= longest_author
- utf8_strwidth(name
);
529 printf(" (%s%*s %10s",
531 format_time(ci
.author_time
,
536 max_digits
, ent
->lno
+ 1 + cnt
);
539 fputs(reset
, stdout
);
543 } while (ch
!= '\n' &&
544 cp
< sb
->final_buf
+ sb
->final_buf_size
);
547 if (sb
->final_buf_size
&& cp
[-1] != '\n')
550 commit_info_destroy(&ci
);
553 static void output(struct blame_scoreboard
*sb
, int option
)
555 struct blame_entry
*ent
;
557 if (option
& OUTPUT_PORCELAIN
) {
558 for (ent
= sb
->ent
; ent
; ent
= ent
->next
) {
560 struct blame_origin
*suspect
;
561 struct commit
*commit
= ent
->suspect
->commit
;
562 if (commit
->object
.flags
& MORE_THAN_ONE_PATH
)
564 for (suspect
= get_blame_suspects(commit
); suspect
; suspect
= suspect
->next
) {
565 if (suspect
->guilty
&& count
++) {
566 commit
->object
.flags
|= MORE_THAN_ONE_PATH
;
573 for (ent
= sb
->ent
; ent
; ent
= ent
->next
) {
574 if (option
& OUTPUT_PORCELAIN
)
575 emit_porcelain(sb
, ent
, option
);
577 emit_other(sb
, ent
, option
);
583 * Add phony grafts for use with -S; this is primarily to
584 * support git's cvsserver that wants to give a linear history
587 static int read_ancestry(const char *graft_file
)
589 FILE *fp
= fopen_or_warn(graft_file
, "r");
590 struct strbuf buf
= STRBUF_INIT
;
593 while (!strbuf_getwholeline(&buf
, fp
, '\n')) {
594 /* The format is just "Commit Parent1 Parent2 ...\n" */
595 struct commit_graft
*graft
= read_graft_line(&buf
);
597 register_commit_graft(the_repository
, graft
, 0);
600 strbuf_release(&buf
);
604 static int update_auto_abbrev(int auto_abbrev
, struct blame_origin
*suspect
)
606 const char *uniq
= find_unique_abbrev(&suspect
->commit
->object
.oid
,
608 int len
= strlen(uniq
);
609 if (auto_abbrev
< len
)
615 * How many columns do we need to show line numbers, authors,
618 static void find_alignment(struct blame_scoreboard
*sb
, int *option
)
620 int longest_src_lines
= 0;
621 int longest_dst_lines
= 0;
622 unsigned largest_score
= 0;
623 struct blame_entry
*e
;
624 int compute_auto_abbrev
= (abbrev
< 0);
625 int auto_abbrev
= DEFAULT_ABBREV
;
627 for (e
= sb
->ent
; e
; e
= e
->next
) {
628 struct blame_origin
*suspect
= e
->suspect
;
631 if (compute_auto_abbrev
)
632 auto_abbrev
= update_auto_abbrev(auto_abbrev
, suspect
);
633 if (strcmp(suspect
->path
, sb
->path
))
634 *option
|= OUTPUT_SHOW_NAME
;
635 num
= strlen(suspect
->path
);
636 if (longest_file
< num
)
638 if (!(suspect
->commit
->object
.flags
& METAINFO_SHOWN
)) {
639 struct commit_info ci
= COMMIT_INFO_INIT
;
640 suspect
->commit
->object
.flags
|= METAINFO_SHOWN
;
641 get_commit_info(suspect
->commit
, &ci
, 1);
642 if (*option
& OUTPUT_SHOW_EMAIL
)
643 num
= utf8_strwidth(ci
.author_mail
.buf
);
645 num
= utf8_strwidth(ci
.author
.buf
);
646 if (longest_author
< num
)
647 longest_author
= num
;
648 commit_info_destroy(&ci
);
650 num
= e
->s_lno
+ e
->num_lines
;
651 if (longest_src_lines
< num
)
652 longest_src_lines
= num
;
653 num
= e
->lno
+ e
->num_lines
;
654 if (longest_dst_lines
< num
)
655 longest_dst_lines
= num
;
656 if (largest_score
< blame_entry_score(sb
, e
))
657 largest_score
= blame_entry_score(sb
, e
);
659 max_orig_digits
= decimal_width(longest_src_lines
);
660 max_digits
= decimal_width(longest_dst_lines
);
661 max_score_digits
= decimal_width(largest_score
);
663 if (compute_auto_abbrev
)
664 /* one more abbrev length is needed for the boundary commit */
665 abbrev
= auto_abbrev
+ 1;
668 static void sanity_check_on_fail(struct blame_scoreboard
*sb
, int baa
)
670 int opt
= OUTPUT_SHOW_SCORE
| OUTPUT_SHOW_NUMBER
| OUTPUT_SHOW_NAME
;
671 find_alignment(sb
, &opt
);
676 static unsigned parse_score(const char *arg
)
679 unsigned long score
= strtoul(arg
, &end
, 10);
685 static const char *add_prefix(const char *prefix
, const char *path
)
687 return prefix_path(prefix
, prefix
? strlen(prefix
) : 0, path
);
690 static int git_blame_config(const char *var
, const char *value
, void *cb
)
692 if (!strcmp(var
, "blame.showroot")) {
693 show_root
= git_config_bool(var
, value
);
696 if (!strcmp(var
, "blame.blankboundary")) {
697 blank_boundary
= git_config_bool(var
, value
);
700 if (!strcmp(var
, "blame.showemail")) {
701 int *output_option
= cb
;
702 if (git_config_bool(var
, value
))
703 *output_option
|= OUTPUT_SHOW_EMAIL
;
705 *output_option
&= ~OUTPUT_SHOW_EMAIL
;
708 if (!strcmp(var
, "blame.date")) {
710 return config_error_nonbool(var
);
711 parse_date_format(value
, &blame_date_mode
);
714 if (!strcmp(var
, "blame.ignorerevsfile")) {
718 ret
= git_config_pathname(&str
, var
, value
);
721 string_list_insert(&ignore_revs_file_list
, str
);
724 if (!strcmp(var
, "blame.markunblamablelines")) {
725 mark_unblamable_lines
= git_config_bool(var
, value
);
728 if (!strcmp(var
, "blame.markignoredlines")) {
729 mark_ignored_lines
= git_config_bool(var
, value
);
732 if (!strcmp(var
, "color.blame.repeatedlines")) {
733 if (color_parse_mem(value
, strlen(value
), repeated_meta_color
))
734 warning(_("invalid value for '%s': '%s'"),
735 "color.blame.repeatedLines", value
);
738 if (!strcmp(var
, "color.blame.highlightrecent")) {
739 parse_color_fields(value
);
743 if (!strcmp(var
, "blame.coloring")) {
744 if (!strcmp(value
, "repeatedLines")) {
745 coloring_mode
|= OUTPUT_COLOR_LINE
;
746 } else if (!strcmp(value
, "highlightRecent")) {
747 coloring_mode
|= OUTPUT_SHOW_AGE_WITH_COLOR
;
748 } else if (!strcmp(value
, "none")) {
749 coloring_mode
&= ~(OUTPUT_COLOR_LINE
|
750 OUTPUT_SHOW_AGE_WITH_COLOR
);
752 warning(_("invalid value for '%s': '%s'"),
753 "blame.coloring", value
);
758 if (git_diff_heuristic_config(var
, value
, cb
) < 0)
760 if (userdiff_config(var
, value
) < 0)
763 return git_default_config(var
, value
, cb
);
766 static int blame_copy_callback(const struct option
*option
, const char *arg
, int unset
)
768 int *opt
= option
->value
;
770 BUG_ON_OPT_NEG(unset
);
773 * -C enables copy from removed files;
774 * -C -C enables copy from existing files, but only
775 * when blaming a new file;
776 * -C -C -C enables copy from existing files for
779 if (*opt
& PICKAXE_BLAME_COPY_HARDER
)
780 *opt
|= PICKAXE_BLAME_COPY_HARDEST
;
781 if (*opt
& PICKAXE_BLAME_COPY
)
782 *opt
|= PICKAXE_BLAME_COPY_HARDER
;
783 *opt
|= PICKAXE_BLAME_COPY
| PICKAXE_BLAME_MOVE
;
786 blame_copy_score
= parse_score(arg
);
790 static int blame_move_callback(const struct option
*option
, const char *arg
, int unset
)
792 int *opt
= option
->value
;
794 BUG_ON_OPT_NEG(unset
);
796 *opt
|= PICKAXE_BLAME_MOVE
;
799 blame_move_score
= parse_score(arg
);
803 static int is_a_rev(const char *name
)
805 struct object_id oid
;
807 if (get_oid(name
, &oid
))
809 return OBJ_NONE
< oid_object_info(the_repository
, &oid
, NULL
);
812 static int peel_to_commit_oid(struct object_id
*oid_ret
, void *cbdata
)
814 struct repository
*r
= ((struct blame_scoreboard
*)cbdata
)->repo
;
815 struct object_id oid
;
817 oidcpy(&oid
, oid_ret
);
820 int kind
= oid_object_info(r
, &oid
, NULL
);
821 if (kind
== OBJ_COMMIT
) {
822 oidcpy(oid_ret
, &oid
);
827 obj
= deref_tag(r
, parse_object(r
, &oid
), NULL
, 0);
830 oidcpy(&oid
, &obj
->oid
);
834 static void build_ignorelist(struct blame_scoreboard
*sb
,
835 struct string_list
*ignore_revs_file_list
,
836 struct string_list
*ignore_rev_list
)
838 struct string_list_item
*i
;
839 struct object_id oid
;
841 oidset_init(&sb
->ignore_list
, 0);
842 for_each_string_list_item(i
, ignore_revs_file_list
) {
843 if (!strcmp(i
->string
, ""))
844 oidset_clear(&sb
->ignore_list
);
846 oidset_parse_file_carefully(&sb
->ignore_list
, i
->string
,
847 peel_to_commit_oid
, sb
);
849 for_each_string_list_item(i
, ignore_rev_list
) {
850 if (get_oid_committish(i
->string
, &oid
) ||
851 peel_to_commit_oid(&oid
, sb
))
852 die(_("cannot find revision %s to ignore"), i
->string
);
853 oidset_insert(&sb
->ignore_list
, &oid
);
857 int cmd_blame(int argc
, const char **argv
, const char *prefix
)
859 struct rev_info revs
;
861 struct blame_scoreboard sb
;
862 struct blame_origin
*o
;
863 struct blame_entry
*ent
= NULL
;
864 long dashdash_pos
, lno
;
865 struct progress_info pi
= { NULL
, 0 };
867 struct string_list range_list
= STRING_LIST_INIT_NODUP
;
868 struct string_list ignore_rev_list
= STRING_LIST_INIT_NODUP
;
869 int output_option
= 0, opt
= 0;
871 const char *revs_file
= NULL
;
872 const char *contents_from
= NULL
;
873 const struct option options
[] = {
874 OPT_BOOL(0, "incremental", &incremental
, N_("show blame entries as we find them, incrementally")),
875 OPT_BOOL('b', NULL
, &blank_boundary
, N_("do not show object names of boundary commits (Default: off)")),
876 OPT_BOOL(0, "root", &show_root
, N_("do not treat root commits as boundaries (Default: off)")),
877 OPT_BOOL(0, "show-stats", &show_stats
, N_("show work cost statistics")),
878 OPT_BOOL(0, "progress", &show_progress
, N_("force progress reporting")),
879 OPT_BIT(0, "score-debug", &output_option
, N_("show output score for blame entries"), OUTPUT_SHOW_SCORE
),
880 OPT_BIT('f', "show-name", &output_option
, N_("show original filename (Default: auto)"), OUTPUT_SHOW_NAME
),
881 OPT_BIT('n', "show-number", &output_option
, N_("show original linenumber (Default: off)"), OUTPUT_SHOW_NUMBER
),
882 OPT_BIT('p', "porcelain", &output_option
, N_("show in a format designed for machine consumption"), OUTPUT_PORCELAIN
),
883 OPT_BIT(0, "line-porcelain", &output_option
, N_("show porcelain format with per-line commit information"), OUTPUT_PORCELAIN
|OUTPUT_LINE_PORCELAIN
),
884 OPT_BIT('c', NULL
, &output_option
, N_("use the same output mode as git-annotate (Default: off)"), OUTPUT_ANNOTATE_COMPAT
),
885 OPT_BIT('t', NULL
, &output_option
, N_("show raw timestamp (Default: off)"), OUTPUT_RAW_TIMESTAMP
),
886 OPT_BIT('l', NULL
, &output_option
, N_("show long commit SHA1 (Default: off)"), OUTPUT_LONG_OBJECT_NAME
),
887 OPT_BIT('s', NULL
, &output_option
, N_("suppress author name and timestamp (Default: off)"), OUTPUT_NO_AUTHOR
),
888 OPT_BIT('e', "show-email", &output_option
, N_("show author email instead of name (Default: off)"), OUTPUT_SHOW_EMAIL
),
889 OPT_BIT('w', NULL
, &xdl_opts
, N_("ignore whitespace differences"), XDF_IGNORE_WHITESPACE
),
890 OPT_STRING_LIST(0, "ignore-rev", &ignore_rev_list
, N_("rev"), N_("ignore <rev> when blaming")),
891 OPT_STRING_LIST(0, "ignore-revs-file", &ignore_revs_file_list
, N_("file"), N_("ignore revisions from <file>")),
892 OPT_BIT(0, "color-lines", &output_option
, N_("color redundant metadata from previous line differently"), OUTPUT_COLOR_LINE
),
893 OPT_BIT(0, "color-by-age", &output_option
, N_("color lines by age"), OUTPUT_SHOW_AGE_WITH_COLOR
),
894 OPT_BIT(0, "minimal", &xdl_opts
, N_("spend extra cycles to find better match"), XDF_NEED_MINIMAL
),
895 OPT_STRING('S', NULL
, &revs_file
, N_("file"), N_("use revisions from <file> instead of calling git-rev-list")),
896 OPT_STRING(0, "contents", &contents_from
, N_("file"), N_("use <file>'s contents as the final image")),
897 OPT_CALLBACK_F('C', NULL
, &opt
, N_("score"), N_("find line copies within and across files"), PARSE_OPT_OPTARG
, blame_copy_callback
),
898 OPT_CALLBACK_F('M', NULL
, &opt
, N_("score"), N_("find line movements within and across files"), PARSE_OPT_OPTARG
, blame_move_callback
),
899 OPT_STRING_LIST('L', NULL
, &range_list
, N_("range"),
900 N_("process only line range <start>,<end> or function :<funcname>")),
901 OPT__ABBREV(&abbrev
),
905 struct parse_opt_ctx_t ctx
;
906 int cmd_is_annotate
= !strcmp(argv
[0], "annotate");
907 struct range_set ranges
;
908 unsigned int range_i
;
910 const int hexsz
= the_hash_algo
->hexsz
;
912 const char *str_usage
= cmd_is_annotate
? annotate_usage
: blame_usage
;
913 const char **opt_usage
= cmd_is_annotate
? annotate_opt_usage
: blame_opt_usage
;
915 setup_default_color_by_age();
916 git_config(git_blame_config
, &output_option
);
917 repo_init_revisions(the_repository
, &revs
, NULL
);
918 revs
.date_mode
= blame_date_mode
;
919 revs
.diffopt
.flags
.allow_textconv
= 1;
920 revs
.diffopt
.flags
.follow_renames
= 1;
922 save_commit_buffer
= 0;
926 parse_options_start(&ctx
, argc
, argv
, prefix
, options
,
927 PARSE_OPT_KEEP_DASHDASH
| PARSE_OPT_KEEP_ARGV0
);
929 switch (parse_options_step(&ctx
, options
, opt_usage
)) {
930 case PARSE_OPT_NON_OPTION
:
931 case PARSE_OPT_UNKNOWN
:
934 case PARSE_OPT_ERROR
:
935 case PARSE_OPT_SUBCOMMAND
:
937 case PARSE_OPT_COMPLETE
:
941 dashdash_pos
= ctx
.cpidx
;
945 if (!strcmp(ctx
.argv
[0], "--reverse")) {
946 ctx
.argv
[0] = "--children";
949 parse_revision_opt(&revs
, &ctx
, options
, opt_usage
);
952 revision_opts_finish(&revs
);
953 no_whole_file_rename
= !revs
.diffopt
.flags
.follow_renames
;
954 xdl_opts
|= revs
.diffopt
.xdl_opts
& XDF_INDENT_HEURISTIC
;
955 revs
.diffopt
.flags
.follow_renames
= 0;
956 argc
= parse_options_end(&ctx
);
958 prepare_repo_settings(the_repository
);
959 the_repository
->settings
.command_requires_full_index
= 0;
961 if (incremental
|| (output_option
& OUTPUT_PORCELAIN
)) {
962 if (show_progress
> 0)
963 die(_("--progress can't be used with --incremental or porcelain formats"));
965 } else if (show_progress
< 0)
966 show_progress
= isatty(2);
968 if (0 < abbrev
&& abbrev
< hexsz
)
969 /* one more abbrev length is needed for the boundary commit */
974 if (revs_file
&& read_ancestry(revs_file
))
975 die_errno("reading graft file '%s' failed", revs_file
);
977 if (cmd_is_annotate
) {
978 output_option
|= OUTPUT_ANNOTATE_COMPAT
;
979 blame_date_mode
.type
= DATE_ISO8601
;
981 blame_date_mode
= revs
.date_mode
;
984 /* The maximum width used to show the dates */
985 switch (blame_date_mode
.type
) {
987 blame_date_width
= sizeof("Thu, 19 Oct 2006 16:00:04 -0700");
989 case DATE_ISO8601_STRICT
:
990 blame_date_width
= sizeof("2006-10-19T16:00:04-07:00");
993 blame_date_width
= sizeof("2006-10-19 16:00:04 -0700");
996 blame_date_width
= sizeof("1161298804 -0700");
999 blame_date_width
= sizeof("1161298804");
1002 blame_date_width
= sizeof("2006-10-19");
1006 * TRANSLATORS: This string is used to tell us the
1007 * maximum display width for a relative timestamp in
1008 * "git blame" output. For C locale, "4 years, 11
1009 * months ago", which takes 22 places, is the longest
1010 * among various forms of relative timestamps, but
1011 * your language may need more or fewer display
1014 blame_date_width
= utf8_strwidth(_("4 years, 11 months ago")) + 1; /* add the null */
1017 /* If the year is shown, no time is shown */
1018 blame_date_width
= sizeof("Thu Oct 19 16:00");
1021 blame_date_width
= sizeof("Thu Oct 19 16:00:04 2006 -0700");
1024 blame_date_width
= strlen(show_date(0, 0, &blame_date_mode
)) + 1; /* add the null */
1027 blame_date_width
-= 1; /* strip the null */
1029 if (revs
.diffopt
.flags
.find_copies_harder
)
1030 opt
|= (PICKAXE_BLAME_COPY
| PICKAXE_BLAME_MOVE
|
1031 PICKAXE_BLAME_COPY_HARDER
);
1034 * We have collected options unknown to us in argv[1..unk]
1035 * which are to be passed to revision machinery if we are
1036 * going to do the "bottom" processing.
1038 * The remaining are:
1040 * (1) if dashdash_pos != 0, it is either
1041 * "blame [revisions] -- <path>" or
1042 * "blame -- <path> <rev>"
1044 * (2) otherwise, it is one of the two:
1045 * "blame [revisions] <path>"
1046 * "blame <path> <rev>"
1048 * Note that we must strip out <path> from the arguments: we do not
1049 * want the path pruning but we may want "bottom" processing.
1052 switch (argc
- dashdash_pos
- 1) {
1055 usage_with_options(opt_usage
, options
);
1056 /* reorder for the new way: <rev> -- <path> */
1062 path
= add_prefix(prefix
, argv
[--argc
]);
1066 usage_with_options(opt_usage
, options
);
1070 usage_with_options(opt_usage
, options
);
1071 if (argc
== 3 && is_a_rev(argv
[argc
- 1])) { /* (2b) */
1072 path
= add_prefix(prefix
, argv
[1]);
1075 if (argc
== 2 && is_a_rev(argv
[1]) && !get_git_work_tree())
1076 die("missing <path> to blame");
1077 path
= add_prefix(prefix
, argv
[argc
- 1]);
1079 argv
[argc
- 1] = "--";
1082 revs
.disable_stdin
= 1;
1083 setup_revisions(argc
, argv
, &revs
, NULL
);
1084 if (!revs
.pending
.nr
&& is_bare_repository()) {
1085 struct commit
*head_commit
;
1086 struct object_id head_oid
;
1088 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
,
1090 !(head_commit
= lookup_commit_reference_gently(revs
.repo
,
1092 die("no such ref: HEAD");
1094 add_pending_object(&revs
, &head_commit
->object
, "HEAD");
1097 init_scoreboard(&sb
);
1099 sb
.contents_from
= contents_from
;
1100 sb
.reverse
= reverse
;
1101 sb
.repo
= the_repository
;
1103 build_ignorelist(&sb
, &ignore_revs_file_list
, &ignore_rev_list
);
1104 string_list_clear(&ignore_revs_file_list
, 0);
1105 string_list_clear(&ignore_rev_list
, 0);
1106 setup_scoreboard(&sb
, &o
);
1109 * Changed-path Bloom filters are disabled when looking
1112 if (!(opt
& PICKAXE_BLAME_COPY
))
1113 setup_blame_bloom_data(&sb
);
1117 if (lno
&& !range_list
.nr
)
1118 string_list_append(&range_list
, "1");
1121 range_set_init(&ranges
, range_list
.nr
);
1122 for (range_i
= 0; range_i
< range_list
.nr
; ++range_i
) {
1124 if (parse_range_arg(range_list
.items
[range_i
].string
,
1125 nth_line_cb
, &sb
, lno
, anchor
,
1126 &bottom
, &top
, sb
.path
,
1127 the_repository
->index
))
1129 if ((!lno
&& (top
|| bottom
)) || lno
< bottom
)
1130 die(Q_("file %s has only %lu line",
1131 "file %s has only %lu lines",
1132 lno
), sb
.path
, lno
);
1135 if (top
< 1 || lno
< top
)
1138 range_set_append_unsafe(&ranges
, bottom
, top
);
1141 sort_and_merge_range_set(&ranges
);
1143 for (range_i
= ranges
.nr
; range_i
> 0; --range_i
) {
1144 const struct range
*r
= &ranges
.ranges
[range_i
- 1];
1145 ent
= blame_entry_prepend(ent
, r
->start
, r
->end
, o
);
1146 num_lines
+= (r
->end
- r
->start
);
1149 num_lines
= sb
.num_lines
;
1152 prio_queue_put(&sb
.commits
, o
->commit
);
1154 blame_origin_decref(o
);
1156 range_set_release(&ranges
);
1157 string_list_clear(&range_list
, 0);
1161 if (blame_move_score
)
1162 sb
.move_score
= blame_move_score
;
1163 if (blame_copy_score
)
1164 sb
.copy_score
= blame_copy_score
;
1166 sb
.debug
= DEBUG_BLAME
;
1167 sb
.on_sanity_fail
= &sanity_check_on_fail
;
1169 sb
.show_root
= show_root
;
1170 sb
.xdl_opts
= xdl_opts
;
1171 sb
.no_whole_file_rename
= no_whole_file_rename
;
1173 read_mailmap(&mailmap
);
1175 sb
.found_guilty_entry
= &found_guilty_entry
;
1176 sb
.found_guilty_entry_data
= &pi
;
1178 pi
.progress
= start_delayed_progress(_("Blaming lines"), num_lines
);
1180 assign_blame(&sb
, opt
);
1182 stop_progress(&pi
.progress
);
1189 blame_sort_final(&sb
);
1191 blame_coalesce(&sb
);
1193 if (!(output_option
& (OUTPUT_COLOR_LINE
| OUTPUT_SHOW_AGE_WITH_COLOR
)))
1194 output_option
|= coloring_mode
;
1196 if (!(output_option
& OUTPUT_PORCELAIN
)) {
1197 find_alignment(&sb
, &output_option
);
1198 if (!*repeated_meta_color
&&
1199 (output_option
& OUTPUT_COLOR_LINE
))
1200 xsnprintf(repeated_meta_color
,
1201 sizeof(repeated_meta_color
),
1202 "%s", GIT_COLOR_CYAN
);
1204 if (output_option
& OUTPUT_ANNOTATE_COMPAT
)
1205 output_option
&= ~(OUTPUT_COLOR_LINE
| OUTPUT_SHOW_AGE_WITH_COLOR
);
1207 output(&sb
, output_option
);
1208 free((void *)sb
.final_buf
);
1209 for (ent
= sb
.ent
; ent
; ) {
1210 struct blame_entry
*e
= ent
->next
;
1216 printf("num read blob: %d\n", sb
.num_read_blob
);
1217 printf("num get patch: %d\n", sb
.num_get_patch
);
1218 printf("num commits: %d\n", sb
.num_commits
);
1222 cleanup_scoreboard(&sb
);
1223 release_revisions(&revs
);