Merge branch 'ma/diff-doc-clarify-regexp-example'
[git] / builtin / rev-list.c
1 #include "cache.h"
2 #include "config.h"
3 #include "commit.h"
4 #include "diff.h"
5 #include "revision.h"
6 #include "list-objects.h"
7 #include "list-objects-filter.h"
8 #include "list-objects-filter-options.h"
9 #include "object.h"
10 #include "object-store.h"
11 #include "pack.h"
12 #include "pack-bitmap.h"
13 #include "builtin.h"
14 #include "log-tree.h"
15 #include "graph.h"
16 #include "bisect.h"
17 #include "progress.h"
18 #include "reflog-walk.h"
19 #include "oidset.h"
20 #include "packfile.h"
21
22 static const char rev_list_usage[] =
23 "git rev-list [OPTION] <commit-id>... [ -- paths... ]\n"
24 "  limiting output:\n"
25 "    --max-count=<n>\n"
26 "    --max-age=<epoch>\n"
27 "    --min-age=<epoch>\n"
28 "    --sparse\n"
29 "    --no-merges\n"
30 "    --min-parents=<n>\n"
31 "    --no-min-parents\n"
32 "    --max-parents=<n>\n"
33 "    --no-max-parents\n"
34 "    --remove-empty\n"
35 "    --all\n"
36 "    --branches\n"
37 "    --tags\n"
38 "    --remotes\n"
39 "    --stdin\n"
40 "    --quiet\n"
41 "  ordering output:\n"
42 "    --topo-order\n"
43 "    --date-order\n"
44 "    --reverse\n"
45 "  formatting output:\n"
46 "    --parents\n"
47 "    --children\n"
48 "    --objects | --objects-edge\n"
49 "    --unpacked\n"
50 "    --header | --pretty\n"
51 "    --[no-]object-names\n"
52 "    --abbrev=<n> | --no-abbrev\n"
53 "    --abbrev-commit\n"
54 "    --left-right\n"
55 "    --count\n"
56 "  special purpose:\n"
57 "    --bisect\n"
58 "    --bisect-vars\n"
59 "    --bisect-all"
60 ;
61
62 static struct progress *progress;
63 static unsigned progress_counter;
64
65 static struct list_objects_filter_options filter_options;
66 static struct oidset omitted_objects;
67 static int arg_print_omitted; /* print objects omitted by filter */
68
69 static struct oidset missing_objects;
70 enum missing_action {
71         MA_ERROR = 0,    /* fail if any missing objects are encountered */
72         MA_ALLOW_ANY,    /* silently allow ALL missing objects */
73         MA_PRINT,        /* print ALL missing objects in special section */
74         MA_ALLOW_PROMISOR, /* silently allow all missing PROMISOR objects */
75 };
76 static enum missing_action arg_missing_action;
77
78 /* display only the oid of each object encountered */
79 static int arg_show_object_names = 1;
80
81 #define DEFAULT_OIDSET_SIZE     (16*1024)
82
83 static void finish_commit(struct commit *commit);
84 static void show_commit(struct commit *commit, void *data)
85 {
86         struct rev_list_info *info = data;
87         struct rev_info *revs = info->revs;
88
89         display_progress(progress, ++progress_counter);
90
91         if (info->flags & REV_LIST_QUIET) {
92                 finish_commit(commit);
93                 return;
94         }
95
96         graph_show_commit(revs->graph);
97
98         if (revs->count) {
99                 if (commit->object.flags & PATCHSAME)
100                         revs->count_same++;
101                 else if (commit->object.flags & SYMMETRIC_LEFT)
102                         revs->count_left++;
103                 else
104                         revs->count_right++;
105                 finish_commit(commit);
106                 return;
107         }
108
109         if (info->show_timestamp)
110                 printf("%"PRItime" ", commit->date);
111         if (info->header_prefix)
112                 fputs(info->header_prefix, stdout);
113
114         if (!revs->graph)
115                 fputs(get_revision_mark(revs, commit), stdout);
116         if (revs->abbrev_commit && revs->abbrev)
117                 fputs(find_unique_abbrev(&commit->object.oid, revs->abbrev),
118                       stdout);
119         else
120                 fputs(oid_to_hex(&commit->object.oid), stdout);
121         if (revs->print_parents) {
122                 struct commit_list *parents = commit->parents;
123                 while (parents) {
124                         printf(" %s", oid_to_hex(&parents->item->object.oid));
125                         parents = parents->next;
126                 }
127         }
128         if (revs->children.name) {
129                 struct commit_list *children;
130
131                 children = lookup_decoration(&revs->children, &commit->object);
132                 while (children) {
133                         printf(" %s", oid_to_hex(&children->item->object.oid));
134                         children = children->next;
135                 }
136         }
137         show_decorations(revs, commit);
138         if (revs->commit_format == CMIT_FMT_ONELINE)
139                 putchar(' ');
140         else
141                 putchar('\n');
142
143         if (revs->verbose_header) {
144                 struct strbuf buf = STRBUF_INIT;
145                 struct pretty_print_context ctx = {0};
146                 ctx.abbrev = revs->abbrev;
147                 ctx.date_mode = revs->date_mode;
148                 ctx.date_mode_explicit = revs->date_mode_explicit;
149                 ctx.fmt = revs->commit_format;
150                 ctx.output_encoding = get_log_output_encoding();
151                 ctx.color = revs->diffopt.use_color;
152                 pretty_print_commit(&ctx, commit, &buf);
153                 if (buf.len) {
154                         if (revs->commit_format != CMIT_FMT_ONELINE)
155                                 graph_show_oneline(revs->graph);
156
157                         graph_show_commit_msg(revs->graph, stdout, &buf);
158
159                         /*
160                          * Add a newline after the commit message.
161                          *
162                          * Usually, this newline produces a blank
163                          * padding line between entries, in which case
164                          * we need to add graph padding on this line.
165                          *
166                          * However, the commit message may not end in a
167                          * newline.  In this case the newline simply
168                          * ends the last line of the commit message,
169                          * and we don't need any graph output.  (This
170                          * always happens with CMIT_FMT_ONELINE, and it
171                          * happens with CMIT_FMT_USERFORMAT when the
172                          * format doesn't explicitly end in a newline.)
173                          */
174                         if (buf.len && buf.buf[buf.len - 1] == '\n')
175                                 graph_show_padding(revs->graph);
176                         putchar(info->hdr_termination);
177                 } else {
178                         /*
179                          * If the message buffer is empty, just show
180                          * the rest of the graph output for this
181                          * commit.
182                          */
183                         if (graph_show_remainder(revs->graph))
184                                 putchar('\n');
185                         if (revs->commit_format == CMIT_FMT_ONELINE)
186                                 putchar('\n');
187                 }
188                 strbuf_release(&buf);
189         } else {
190                 if (graph_show_remainder(revs->graph))
191                         putchar('\n');
192         }
193         maybe_flush_or_die(stdout, "stdout");
194         finish_commit(commit);
195 }
196
197 static void finish_commit(struct commit *commit)
198 {
199         if (commit->parents) {
200                 free_commit_list(commit->parents);
201                 commit->parents = NULL;
202         }
203         free_commit_buffer(the_repository->parsed_objects,
204                            commit);
205 }
206
207 static inline void finish_object__ma(struct object *obj)
208 {
209         /*
210          * Whether or not we try to dynamically fetch missing objects
211          * from the server, we currently DO NOT have the object.  We
212          * can either print, allow (ignore), or conditionally allow
213          * (ignore) them.
214          */
215         switch (arg_missing_action) {
216         case MA_ERROR:
217                 die("missing %s object '%s'",
218                     type_name(obj->type), oid_to_hex(&obj->oid));
219                 return;
220
221         case MA_ALLOW_ANY:
222                 return;
223
224         case MA_PRINT:
225                 oidset_insert(&missing_objects, &obj->oid);
226                 return;
227
228         case MA_ALLOW_PROMISOR:
229                 if (is_promisor_object(&obj->oid))
230                         return;
231                 die("unexpected missing %s object '%s'",
232                     type_name(obj->type), oid_to_hex(&obj->oid));
233                 return;
234
235         default:
236                 BUG("unhandled missing_action");
237                 return;
238         }
239 }
240
241 static int finish_object(struct object *obj, const char *name, void *cb_data)
242 {
243         struct rev_list_info *info = cb_data;
244         if (oid_object_info_extended(the_repository, &obj->oid, NULL, 0) < 0) {
245                 finish_object__ma(obj);
246                 return 1;
247         }
248         if (info->revs->verify_objects && !obj->parsed && obj->type != OBJ_COMMIT)
249                 parse_object(the_repository, &obj->oid);
250         return 0;
251 }
252
253 static void show_object(struct object *obj, const char *name, void *cb_data)
254 {
255         struct rev_list_info *info = cb_data;
256         if (finish_object(obj, name, cb_data))
257                 return;
258         display_progress(progress, ++progress_counter);
259         if (info->flags & REV_LIST_QUIET)
260                 return;
261         if (arg_show_object_names)
262                 show_object_with_name(stdout, obj, name);
263         else
264                 printf("%s\n", oid_to_hex(&obj->oid));
265 }
266
267 static void show_edge(struct commit *commit)
268 {
269         printf("-%s\n", oid_to_hex(&commit->object.oid));
270 }
271
272 static void print_var_str(const char *var, const char *val)
273 {
274         printf("%s='%s'\n", var, val);
275 }
276
277 static void print_var_int(const char *var, int val)
278 {
279         printf("%s=%d\n", var, val);
280 }
281
282 static int show_bisect_vars(struct rev_list_info *info, int reaches, int all)
283 {
284         int cnt, flags = info->flags;
285         char hex[GIT_MAX_HEXSZ + 1] = "";
286         struct commit_list *tried;
287         struct rev_info *revs = info->revs;
288
289         if (!revs->commits)
290                 return 1;
291
292         revs->commits = filter_skipped(revs->commits, &tried,
293                                        flags & BISECT_SHOW_ALL,
294                                        NULL, NULL);
295
296         /*
297          * revs->commits can reach "reaches" commits among
298          * "all" commits.  If it is good, then there are
299          * (all-reaches) commits left to be bisected.
300          * On the other hand, if it is bad, then the set
301          * to bisect is "reaches".
302          * A bisect set of size N has (N-1) commits further
303          * to test, as we already know one bad one.
304          */
305         cnt = all - reaches;
306         if (cnt < reaches)
307                 cnt = reaches;
308
309         if (revs->commits)
310                 oid_to_hex_r(hex, &revs->commits->item->object.oid);
311
312         if (flags & BISECT_SHOW_ALL) {
313                 traverse_commit_list(revs, show_commit, show_object, info);
314                 printf("------\n");
315         }
316
317         print_var_str("bisect_rev", hex);
318         print_var_int("bisect_nr", cnt - 1);
319         print_var_int("bisect_good", all - reaches - 1);
320         print_var_int("bisect_bad", reaches - 1);
321         print_var_int("bisect_all", all);
322         print_var_int("bisect_steps", estimate_bisect_steps(all));
323
324         return 0;
325 }
326
327 static int show_object_fast(
328         const struct object_id *oid,
329         enum object_type type,
330         int exclude,
331         uint32_t name_hash,
332         struct packed_git *found_pack,
333         off_t found_offset)
334 {
335         fprintf(stdout, "%s\n", oid_to_hex(oid));
336         return 1;
337 }
338
339 static inline int parse_missing_action_value(const char *value)
340 {
341         if (!strcmp(value, "error")) {
342                 arg_missing_action = MA_ERROR;
343                 return 1;
344         }
345
346         if (!strcmp(value, "allow-any")) {
347                 arg_missing_action = MA_ALLOW_ANY;
348                 fetch_if_missing = 0;
349                 return 1;
350         }
351
352         if (!strcmp(value, "print")) {
353                 arg_missing_action = MA_PRINT;
354                 fetch_if_missing = 0;
355                 return 1;
356         }
357
358         if (!strcmp(value, "allow-promisor")) {
359                 arg_missing_action = MA_ALLOW_PROMISOR;
360                 fetch_if_missing = 0;
361                 return 1;
362         }
363
364         return 0;
365 }
366
367 int cmd_rev_list(int argc, const char **argv, const char *prefix)
368 {
369         struct rev_info revs;
370         struct rev_list_info info;
371         struct setup_revision_opt s_r_opt = {
372                 .allow_exclude_promisor_objects = 1,
373         };
374         int i;
375         int bisect_list = 0;
376         int bisect_show_vars = 0;
377         int bisect_find_all = 0;
378         int use_bitmap_index = 0;
379         const char *show_progress = NULL;
380
381         if (argc == 2 && !strcmp(argv[1], "-h"))
382                 usage(rev_list_usage);
383
384         git_config(git_default_config, NULL);
385         repo_init_revisions(the_repository, &revs, prefix);
386         revs.abbrev = DEFAULT_ABBREV;
387         revs.commit_format = CMIT_FMT_UNSPECIFIED;
388
389         /*
390          * Scan the argument list before invoking setup_revisions(), so that we
391          * know if fetch_if_missing needs to be set to 0.
392          *
393          * "--exclude-promisor-objects" acts as a pre-filter on missing objects
394          * by not crossing the boundary from realized objects to promisor
395          * objects.
396          *
397          * Let "--missing" to conditionally set fetch_if_missing.
398          */
399         for (i = 1; i < argc; i++) {
400                 const char *arg = argv[i];
401                 if (!strcmp(arg, "--exclude-promisor-objects")) {
402                         fetch_if_missing = 0;
403                         revs.exclude_promisor_objects = 1;
404                         break;
405                 }
406         }
407         for (i = 1; i < argc; i++) {
408                 const char *arg = argv[i];
409                 if (skip_prefix(arg, "--missing=", &arg)) {
410                         if (revs.exclude_promisor_objects)
411                                 die(_("cannot combine --exclude-promisor-objects and --missing"));
412                         if (parse_missing_action_value(arg))
413                                 break;
414                 }
415         }
416
417         if (arg_missing_action)
418                 revs.do_not_die_on_missing_tree = 1;
419
420         argc = setup_revisions(argc, argv, &revs, &s_r_opt);
421
422         memset(&info, 0, sizeof(info));
423         info.revs = &revs;
424         if (revs.bisect)
425                 bisect_list = 1;
426
427         if (revs.diffopt.flags.quick)
428                 info.flags |= REV_LIST_QUIET;
429         for (i = 1 ; i < argc; i++) {
430                 const char *arg = argv[i];
431
432                 if (!strcmp(arg, "--header")) {
433                         revs.verbose_header = 1;
434                         continue;
435                 }
436                 if (!strcmp(arg, "--timestamp")) {
437                         info.show_timestamp = 1;
438                         continue;
439                 }
440                 if (!strcmp(arg, "--bisect")) {
441                         bisect_list = 1;
442                         continue;
443                 }
444                 if (!strcmp(arg, "--bisect-all")) {
445                         bisect_list = 1;
446                         bisect_find_all = 1;
447                         info.flags |= BISECT_SHOW_ALL;
448                         revs.show_decorations = 1;
449                         continue;
450                 }
451                 if (!strcmp(arg, "--bisect-vars")) {
452                         bisect_list = 1;
453                         bisect_show_vars = 1;
454                         continue;
455                 }
456                 if (!strcmp(arg, "--use-bitmap-index")) {
457                         use_bitmap_index = 1;
458                         continue;
459                 }
460                 if (!strcmp(arg, "--test-bitmap")) {
461                         test_bitmap_walk(&revs);
462                         return 0;
463                 }
464                 if (skip_prefix(arg, "--progress=", &arg)) {
465                         show_progress = arg;
466                         continue;
467                 }
468
469                 if (skip_prefix(arg, ("--" CL_ARG__FILTER "="), &arg)) {
470                         parse_list_objects_filter(&filter_options, arg);
471                         if (filter_options.choice && !revs.blob_objects)
472                                 die(_("object filtering requires --objects"));
473                         continue;
474                 }
475                 if (!strcmp(arg, ("--no-" CL_ARG__FILTER))) {
476                         list_objects_filter_set_no_filter(&filter_options);
477                         continue;
478                 }
479                 if (!strcmp(arg, "--filter-print-omitted")) {
480                         arg_print_omitted = 1;
481                         continue;
482                 }
483
484                 if (!strcmp(arg, "--exclude-promisor-objects"))
485                         continue; /* already handled above */
486                 if (skip_prefix(arg, "--missing=", &arg))
487                         continue; /* already handled above */
488
489                 if (!strcmp(arg, ("--no-object-names"))) {
490                         arg_show_object_names = 0;
491                         continue;
492                 }
493
494                 if (!strcmp(arg, ("--object-names"))) {
495                         arg_show_object_names = 1;
496                         continue;
497                 }
498
499                 usage(rev_list_usage);
500
501         }
502         if (revs.commit_format != CMIT_FMT_UNSPECIFIED) {
503                 /* The command line has a --pretty  */
504                 info.hdr_termination = '\n';
505                 if (revs.commit_format == CMIT_FMT_ONELINE)
506                         info.header_prefix = "";
507                 else
508                         info.header_prefix = "commit ";
509         }
510         else if (revs.verbose_header)
511                 /* Only --header was specified */
512                 revs.commit_format = CMIT_FMT_RAW;
513
514         if ((!revs.commits && reflog_walk_empty(revs.reflog_info) &&
515              (!(revs.tag_objects || revs.tree_objects || revs.blob_objects) &&
516               !revs.pending.nr) &&
517              !revs.rev_input_given && !revs.read_from_stdin) ||
518             revs.diff)
519                 usage(rev_list_usage);
520
521         if (revs.show_notes)
522                 die(_("rev-list does not support display of notes"));
523
524         if (filter_options.choice && use_bitmap_index)
525                 die(_("cannot combine --use-bitmap-index with object filtering"));
526
527         save_commit_buffer = (revs.verbose_header ||
528                               revs.grep_filter.pattern_list ||
529                               revs.grep_filter.header_list);
530         if (bisect_list)
531                 revs.limited = 1;
532
533         if (show_progress)
534                 progress = start_delayed_progress(show_progress, 0);
535
536         if (use_bitmap_index && !revs.prune) {
537                 if (revs.count && !revs.left_right && !revs.cherry_mark) {
538                         uint32_t commit_count;
539                         int max_count = revs.max_count;
540                         struct bitmap_index *bitmap_git;
541                         if ((bitmap_git = prepare_bitmap_walk(&revs))) {
542                                 count_bitmap_commit_list(bitmap_git, &commit_count, NULL, NULL, NULL);
543                                 if (max_count >= 0 && max_count < commit_count)
544                                         commit_count = max_count;
545                                 printf("%d\n", commit_count);
546                                 free_bitmap_index(bitmap_git);
547                                 return 0;
548                         }
549                 } else if (revs.max_count < 0 &&
550                            revs.tag_objects && revs.tree_objects && revs.blob_objects) {
551                         struct bitmap_index *bitmap_git;
552                         if ((bitmap_git = prepare_bitmap_walk(&revs))) {
553                                 traverse_bitmap_commit_list(bitmap_git, &show_object_fast);
554                                 free_bitmap_index(bitmap_git);
555                                 return 0;
556                         }
557                 }
558         }
559
560         if (prepare_revision_walk(&revs))
561                 die("revision walk setup failed");
562         if (revs.tree_objects)
563                 mark_edges_uninteresting(&revs, show_edge, 0);
564
565         if (bisect_list) {
566                 int reaches, all;
567
568                 find_bisection(&revs.commits, &reaches, &all, bisect_find_all);
569
570                 if (bisect_show_vars)
571                         return show_bisect_vars(&info, reaches, all);
572         }
573
574         if (arg_print_omitted)
575                 oidset_init(&omitted_objects, DEFAULT_OIDSET_SIZE);
576         if (arg_missing_action == MA_PRINT)
577                 oidset_init(&missing_objects, DEFAULT_OIDSET_SIZE);
578
579         traverse_commit_list_filtered(
580                 &filter_options, &revs, show_commit, show_object, &info,
581                 (arg_print_omitted ? &omitted_objects : NULL));
582
583         if (arg_print_omitted) {
584                 struct oidset_iter iter;
585                 struct object_id *oid;
586                 oidset_iter_init(&omitted_objects, &iter);
587                 while ((oid = oidset_iter_next(&iter)))
588                         printf("~%s\n", oid_to_hex(oid));
589                 oidset_clear(&omitted_objects);
590         }
591         if (arg_missing_action == MA_PRINT) {
592                 struct oidset_iter iter;
593                 struct object_id *oid;
594                 oidset_iter_init(&missing_objects, &iter);
595                 while ((oid = oidset_iter_next(&iter)))
596                         printf("?%s\n", oid_to_hex(oid));
597                 oidset_clear(&missing_objects);
598         }
599
600         stop_progress(&progress);
601
602         if (revs.count) {
603                 if (revs.left_right && revs.cherry_mark)
604                         printf("%d\t%d\t%d\n", revs.count_left, revs.count_right, revs.count_same);
605                 else if (revs.left_right)
606                         printf("%d\t%d\n", revs.count_left, revs.count_right);
607                 else if (revs.cherry_mark)
608                         printf("%d\t%d\n", revs.count_left + revs.count_right, revs.count_same);
609                 else
610                         printf("%d\n", revs.count_left + revs.count_right);
611         }
612
613         return 0;
614 }