1#include "cache.h"
2#include "config.h"
3#include "lockfile.h"
4#include "commit.h"
5#include "tag.h"
6#include "blob.h"
7#include "refs.h"
8#include "builtin.h"
9#include "exec_cmd.h"
10#include "parse-options.h"
11#include "revision.h"
12#include "diff.h"
13#include "hashmap.h"
14#include "argv-array.h"
15#include "run-command.h"
16#include "object-store.h"
17#include "revision.h"
18#include "list-objects.h"
19
20#define MAX_TAGS (FLAG_BITS - 1)
21
22static const char * const describe_usage[] = {
23 N_("git describe [<options>] [<commit-ish>...]"),
24 N_("git describe [<options>] --dirty"),
25 NULL
26};
27
28static int debug; /* Display lots of verbose info */
29static int all; /* Any valid ref can be used */
30static int tags; /* Allow lightweight tags */
31static int longformat;
32static int first_parent;
33static int abbrev = -1; /* unspecified */
34static int max_candidates = 10;
35static struct hashmap names;
36static int have_util;
37static struct string_list patterns = STRING_LIST_INIT_NODUP;
38static struct string_list exclude_patterns = STRING_LIST_INIT_NODUP;
39static int always;
40static const char *suffix, *dirty, *broken;
41
42/* diff-index command arguments to check if working tree is dirty. */
43static const char *diff_index_args[] = {
44 "diff-index", "--quiet", "HEAD", "--", NULL
45};
46
47struct commit_name {
48 struct hashmap_entry entry;
49 struct object_id peeled;
50 struct tag *tag;
51 unsigned prio:2; /* annotated tag = 2, tag = 1, head = 0 */
52 unsigned name_checked:1;
53 struct object_id oid;
54 char *path;
55};
56
57static const char *prio_names[] = {
58 N_("head"), N_("lightweight"), N_("annotated"),
59};
60
61static int commit_name_cmp(const void *unused_cmp_data,
62 const void *entry,
63 const void *entry_or_key,
64 const void *peeled)
65{
66 const struct commit_name *cn1 = entry;
67 const struct commit_name *cn2 = entry_or_key;
68
69 return oidcmp(&cn1->peeled, peeled ? peeled : &cn2->peeled);
70}
71
72static inline struct commit_name *find_commit_name(const struct object_id *peeled)
73{
74 return hashmap_get_from_hash(&names, sha1hash(peeled->hash), peeled->hash);
75}
76
77static int replace_name(struct commit_name *e,
78 int prio,
79 const struct object_id *oid,
80 struct tag **tag)
81{
82 if (!e || e->prio < prio)
83 return 1;
84
85 if (e->prio == 2 && prio == 2) {
86 /* Multiple annotated tags point to the same commit.
87 * Select one to keep based upon their tagger date.
88 */
89 struct tag *t;
90
91 if (!e->tag) {
92 t = lookup_tag(&e->oid);
93 if (!t || parse_tag(t))
94 return 1;
95 e->tag = t;
96 }
97
98 t = lookup_tag(oid);
99 if (!t || parse_tag(t))
100 return 0;
101 *tag = t;
102
103 if (e->tag->date < t->date)
104 return 1;
105 }
106
107 return 0;
108}
109
110static void add_to_known_names(const char *path,
111 const struct object_id *peeled,
112 int prio,
113 const struct object_id *oid)
114{
115 struct commit_name *e = find_commit_name(peeled);
116 struct tag *tag = NULL;
117 if (replace_name(e, prio, oid, &tag)) {
118 if (!e) {
119 e = xmalloc(sizeof(struct commit_name));
120 oidcpy(&e->peeled, peeled);
121 hashmap_entry_init(e, sha1hash(peeled->hash));
122 hashmap_add(&names, e);
123 e->path = NULL;
124 }
125 e->tag = tag;
126 e->prio = prio;
127 e->name_checked = 0;
128 oidcpy(&e->oid, oid);
129 free(e->path);
130 e->path = xstrdup(path);
131 }
132}
133
134static int get_name(const char *path, const struct object_id *oid, int flag, void *cb_data)
135{
136 int is_tag = 0;
137 struct object_id peeled;
138 int is_annotated, prio;
139 const char *path_to_match = NULL;
140
141 if (skip_prefix(path, "refs/tags/", &path_to_match)) {
142 is_tag = 1;
143 } else if (all) {
144 if ((exclude_patterns.nr || patterns.nr) &&
145 !skip_prefix(path, "refs/heads/", &path_to_match) &&
146 !skip_prefix(path, "refs/remotes/", &path_to_match)) {
147 /* Only accept reference of known type if there are match/exclude patterns */
148 return 0;
149 }
150 } else {
151 /* Reject anything outside refs/tags/ unless --all */
152 return 0;
153 }
154
155 /*
156 * If we're given exclude patterns, first exclude any tag which match
157 * any of the exclude pattern.
158 */
159 if (exclude_patterns.nr) {
160 struct string_list_item *item;
161
162 for_each_string_list_item(item, &exclude_patterns) {
163 if (!wildmatch(item->string, path_to_match, 0))
164 return 0;
165 }
166 }
167
168 /*
169 * If we're given patterns, accept only tags which match at least one
170 * pattern.
171 */
172 if (patterns.nr) {
173 int found = 0;
174 struct string_list_item *item;
175
176 for_each_string_list_item(item, &patterns) {
177 if (!wildmatch(item->string, path_to_match, 0)) {
178 found = 1;
179 break;
180 }
181 }
182
183 if (!found)
184 return 0;
185 }
186
187 /* Is it annotated? */
188 if (!peel_ref(path, &peeled)) {
189 is_annotated = !!oidcmp(oid, &peeled);
190 } else {
191 oidcpy(&peeled, oid);
192 is_annotated = 0;
193 }
194
195 /*
196 * By default, we only use annotated tags, but with --tags
197 * we fall back to lightweight ones (even without --tags,
198 * we still remember lightweight ones, only to give hints
199 * in an error message). --all allows any refs to be used.
200 */
201 if (is_annotated)
202 prio = 2;
203 else if (is_tag)
204 prio = 1;
205 else
206 prio = 0;
207
208 add_to_known_names(all ? path + 5 : path + 10, &peeled, prio, oid);
209 return 0;
210}
211
212struct possible_tag {
213 struct commit_name *name;
214 int depth;
215 int found_order;
216 unsigned flag_within;
217};
218
219static int compare_pt(const void *a_, const void *b_)
220{
221 struct possible_tag *a = (struct possible_tag *)a_;
222 struct possible_tag *b = (struct possible_tag *)b_;
223 if (a->depth != b->depth)
224 return a->depth - b->depth;
225 if (a->found_order != b->found_order)
226 return a->found_order - b->found_order;
227 return 0;
228}
229
230static unsigned long finish_depth_computation(
231 struct commit_list **list,
232 struct possible_tag *best)
233{
234 unsigned long seen_commits = 0;
235 while (*list) {
236 struct commit *c = pop_commit(list);
237 struct commit_list *parents = c->parents;
238 seen_commits++;
239 if (c->object.flags & best->flag_within) {
240 struct commit_list *a = *list;
241 while (a) {
242 struct commit *i = a->item;
243 if (!(i->object.flags & best->flag_within))
244 break;
245 a = a->next;
246 }
247 if (!a)
248 break;
249 } else
250 best->depth++;
251 while (parents) {
252 struct commit *p = parents->item;
253 parse_commit(p);
254 if (!(p->object.flags & SEEN))
255 commit_list_insert_by_date(p, list);
256 p->object.flags |= c->object.flags;
257 parents = parents->next;
258 }
259 }
260 return seen_commits;
261}
262
263static void append_name(struct commit_name *n, struct strbuf *dst)
264{
265 if (n->prio == 2 && !n->tag) {
266 n->tag = lookup_tag(&n->oid);
267 if (!n->tag || parse_tag(n->tag))
268 die(_("annotated tag %s not available"), n->path);
269 }
270 if (n->tag && !n->name_checked) {
271 if (!n->tag->tag)
272 die(_("annotated tag %s has no embedded name"), n->path);
273 if (strcmp(n->tag->tag, all ? n->path + 5 : n->path))
274 warning(_("tag '%s' is really '%s' here"), n->tag->tag, n->path);
275 n->name_checked = 1;
276 }
277
278 if (n->tag) {
279 if (all)
280 strbuf_addstr(dst, "tags/");
281 strbuf_addstr(dst, n->tag->tag);
282 } else {
283 strbuf_addstr(dst, n->path);
284 }
285}
286
287static void append_suffix(int depth, const struct object_id *oid, struct strbuf *dst)
288{
289 strbuf_addf(dst, "-%d-g%s", depth, find_unique_abbrev(oid, abbrev));
290}
291
292static void describe_commit(struct object_id *oid, struct strbuf *dst)
293{
294 struct commit *cmit, *gave_up_on = NULL;
295 struct commit_list *list;
296 struct commit_name *n;
297 struct possible_tag all_matches[MAX_TAGS];
298 unsigned int match_cnt = 0, annotated_cnt = 0, cur_match;
299 unsigned long seen_commits = 0;
300 unsigned int unannotated_cnt = 0;
301
302 cmit = lookup_commit_reference(oid);
303
304 n = find_commit_name(&cmit->object.oid);
305 if (n && (tags || all || n->prio == 2)) {
306 /*
307 * Exact match to an existing ref.
308 */
309 append_name(n, dst);
310 if (longformat)
311 append_suffix(0, n->tag ? &n->tag->tagged->oid : oid, dst);
312 if (suffix)
313 strbuf_addstr(dst, suffix);
314 return;
315 }
316
317 if (!max_candidates)
318 die(_("no tag exactly matches '%s'"), oid_to_hex(&cmit->object.oid));
319 if (debug)
320 fprintf(stderr, _("No exact match on refs or tags, searching to describe\n"));
321
322 if (!have_util) {
323 struct hashmap_iter iter;
324 struct commit *c;
325 struct commit_name *n = hashmap_iter_first(&names, &iter);
326 for (; n; n = hashmap_iter_next(&iter)) {
327 c = lookup_commit_reference_gently(&n->peeled, 1);
328 if (c)
329 c->util = n;
330 }
331 have_util = 1;
332 }
333
334 list = NULL;
335 cmit->object.flags = SEEN;
336 commit_list_insert(cmit, &list);
337 while (list) {
338 struct commit *c = pop_commit(&list);
339 struct commit_list *parents = c->parents;
340 seen_commits++;
341 n = c->util;
342 if (n) {
343 if (!tags && !all && n->prio < 2) {
344 unannotated_cnt++;
345 } else if (match_cnt < max_candidates) {
346 struct possible_tag *t = &all_matches[match_cnt++];
347 t->name = n;
348 t->depth = seen_commits - 1;
349 t->flag_within = 1u << match_cnt;
350 t->found_order = match_cnt;
351 c->object.flags |= t->flag_within;
352 if (n->prio == 2)
353 annotated_cnt++;
354 }
355 else {
356 gave_up_on = c;
357 break;
358 }
359 }
360 for (cur_match = 0; cur_match < match_cnt; cur_match++) {
361 struct possible_tag *t = &all_matches[cur_match];
362 if (!(c->object.flags & t->flag_within))
363 t->depth++;
364 }
365 if (annotated_cnt && !list) {
366 if (debug)
367 fprintf(stderr, _("finished search at %s\n"),
368 oid_to_hex(&c->object.oid));
369 break;
370 }
371 while (parents) {
372 struct commit *p = parents->item;
373 parse_commit(p);
374 if (!(p->object.flags & SEEN))
375 commit_list_insert_by_date(p, &list);
376 p->object.flags |= c->object.flags;
377 parents = parents->next;
378
379 if (first_parent)
380 break;
381 }
382 }
383
384 if (!match_cnt) {
385 struct object_id *cmit_oid = &cmit->object.oid;
386 if (always) {
387 strbuf_add_unique_abbrev(dst, cmit_oid, abbrev);
388 if (suffix)
389 strbuf_addstr(dst, suffix);
390 return;
391 }
392 if (unannotated_cnt)
393 die(_("No annotated tags can describe '%s'.\n"
394 "However, there were unannotated tags: try --tags."),
395 oid_to_hex(cmit_oid));
396 else
397 die(_("No tags can describe '%s'.\n"
398 "Try --always, or create some tags."),
399 oid_to_hex(cmit_oid));
400 }
401
402 QSORT(all_matches, match_cnt, compare_pt);
403
404 if (gave_up_on) {
405 commit_list_insert_by_date(gave_up_on, &list);
406 seen_commits--;
407 }
408 seen_commits += finish_depth_computation(&list, &all_matches[0]);
409 free_commit_list(list);
410
411 if (debug) {
412 static int label_width = -1;
413 if (label_width < 0) {
414 int i, w;
415 for (i = 0; i < ARRAY_SIZE(prio_names); i++) {
416 w = strlen(_(prio_names[i]));
417 if (label_width < w)
418 label_width = w;
419 }
420 }
421 for (cur_match = 0; cur_match < match_cnt; cur_match++) {
422 struct possible_tag *t = &all_matches[cur_match];
423 fprintf(stderr, " %-*s %8d %s\n",
424 label_width, _(prio_names[t->name->prio]),
425 t->depth, t->name->path);
426 }
427 fprintf(stderr, _("traversed %lu commits\n"), seen_commits);
428 if (gave_up_on) {
429 fprintf(stderr,
430 _("more than %i tags found; listed %i most recent\n"
431 "gave up search at %s\n"),
432 max_candidates, max_candidates,
433 oid_to_hex(&gave_up_on->object.oid));
434 }
435 }
436
437 append_name(all_matches[0].name, dst);
438 if (abbrev)
439 append_suffix(all_matches[0].depth, &cmit->object.oid, dst);
440 if (suffix)
441 strbuf_addstr(dst, suffix);
442}
443
444struct process_commit_data {
445 struct object_id current_commit;
446 struct object_id looking_for;
447 struct strbuf *dst;
448 struct rev_info *revs;
449};
450
451static void process_commit(struct commit *commit, void *data)
452{
453 struct process_commit_data *pcd = data;
454 pcd->current_commit = commit->object.oid;
455}
456
457static void process_object(struct object *obj, const char *path, void *data)
458{
459 struct process_commit_data *pcd = data;
460
461 if (!oidcmp(&pcd->looking_for, &obj->oid) && !pcd->dst->len) {
462 reset_revision_walk();
463 describe_commit(&pcd->current_commit, pcd->dst);
464 strbuf_addf(pcd->dst, ":%s", path);
465 free_commit_list(pcd->revs->commits);
466 pcd->revs->commits = NULL;
467 }
468}
469
470static void describe_blob(struct object_id oid, struct strbuf *dst)
471{
472 struct rev_info revs;
473 struct argv_array args = ARGV_ARRAY_INIT;
474 struct process_commit_data pcd = { null_oid, oid, dst, &revs};
475
476 argv_array_pushl(&args, "internal: The first arg is not parsed",
477 "--objects", "--in-commit-order", "--reverse", "HEAD",
478 NULL);
479
480 init_revisions(&revs, NULL);
481 if (setup_revisions(args.argc, args.argv, &revs, NULL) > 1)
482 BUG("setup_revisions could not handle all args?");
483
484 if (prepare_revision_walk(&revs))
485 die("revision walk setup failed");
486
487 traverse_commit_list(&revs, process_commit, process_object, &pcd);
488 reset_revision_walk();
489}
490
491static void describe(const char *arg, int last_one)
492{
493 struct object_id oid;
494 struct commit *cmit;
495 struct strbuf sb = STRBUF_INIT;
496
497 if (debug)
498 fprintf(stderr, _("describe %s\n"), arg);
499
500 if (get_oid(arg, &oid))
501 die(_("Not a valid object name %s"), arg);
502 cmit = lookup_commit_reference_gently(&oid, 1);
503
504 if (cmit)
505 describe_commit(&oid, &sb);
506 else if (oid_object_info(the_repository, &oid, NULL) == OBJ_BLOB)
507 describe_blob(oid, &sb);
508 else
509 die(_("%s is neither a commit nor blob"), arg);
510
511 puts(sb.buf);
512
513 if (!last_one)
514 clear_commit_marks(cmit, -1);
515
516 strbuf_release(&sb);
517}
518
519int cmd_describe(int argc, const char **argv, const char *prefix)
520{
521 int contains = 0;
522 struct option options[] = {
523 OPT_BOOL(0, "contains", &contains, N_("find the tag that comes after the commit")),
524 OPT_BOOL(0, "debug", &debug, N_("debug search strategy on stderr")),
525 OPT_BOOL(0, "all", &all, N_("use any ref")),
526 OPT_BOOL(0, "tags", &tags, N_("use any tag, even unannotated")),
527 OPT_BOOL(0, "long", &longformat, N_("always use long format")),
528 OPT_BOOL(0, "first-parent", &first_parent, N_("only follow first parent")),
529 OPT__ABBREV(&abbrev),
530 OPT_SET_INT(0, "exact-match", &max_candidates,
531 N_("only output exact matches"), 0),
532 OPT_INTEGER(0, "candidates", &max_candidates,
533 N_("consider <n> most recent tags (default: 10)")),
534 OPT_STRING_LIST(0, "match", &patterns, N_("pattern"),
535 N_("only consider tags matching <pattern>")),
536 OPT_STRING_LIST(0, "exclude", &exclude_patterns, N_("pattern"),
537 N_("do not consider tags matching <pattern>")),
538 OPT_BOOL(0, "always", &always,
539 N_("show abbreviated commit object as fallback")),
540 {OPTION_STRING, 0, "dirty", &dirty, N_("mark"),
541 N_("append <mark> on dirty working tree (default: \"-dirty\")"),
542 PARSE_OPT_OPTARG, NULL, (intptr_t) "-dirty"},
543 {OPTION_STRING, 0, "broken", &broken, N_("mark"),
544 N_("append <mark> on broken working tree (default: \"-broken\")"),
545 PARSE_OPT_OPTARG, NULL, (intptr_t) "-broken"},
546 OPT_END(),
547 };
548
549 git_config(git_default_config, NULL);
550 argc = parse_options(argc, argv, prefix, options, describe_usage, 0);
551 if (abbrev < 0)
552 abbrev = DEFAULT_ABBREV;
553
554 if (max_candidates < 0)
555 max_candidates = 0;
556 else if (max_candidates > MAX_TAGS)
557 max_candidates = MAX_TAGS;
558
559 save_commit_buffer = 0;
560
561 if (longformat && abbrev == 0)
562 die(_("--long is incompatible with --abbrev=0"));
563
564 if (contains) {
565 struct string_list_item *item;
566 struct argv_array args;
567
568 argv_array_init(&args);
569 argv_array_pushl(&args, "name-rev",
570 "--peel-tag", "--name-only", "--no-undefined",
571 NULL);
572 if (always)
573 argv_array_push(&args, "--always");
574 if (!all) {
575 argv_array_push(&args, "--tags");
576 for_each_string_list_item(item, &patterns)
577 argv_array_pushf(&args, "--refs=refs/tags/%s", item->string);
578 for_each_string_list_item(item, &exclude_patterns)
579 argv_array_pushf(&args, "--exclude=refs/tags/%s", item->string);
580 }
581 if (argc)
582 argv_array_pushv(&args, argv);
583 else
584 argv_array_push(&args, "HEAD");
585 return cmd_name_rev(args.argc, args.argv, prefix);
586 }
587
588 hashmap_init(&names, commit_name_cmp, NULL, 0);
589 for_each_rawref(get_name, NULL);
590 if (!hashmap_get_size(&names) && !always)
591 die(_("No names found, cannot describe anything."));
592
593 if (argc == 0) {
594 if (broken) {
595 struct child_process cp = CHILD_PROCESS_INIT;
596 argv_array_pushv(&cp.args, diff_index_args);
597 cp.git_cmd = 1;
598 cp.no_stdin = 1;
599 cp.no_stdout = 1;
600
601 if (!dirty)
602 dirty = "-dirty";
603
604 switch (run_command(&cp)) {
605 case 0:
606 suffix = NULL;
607 break;
608 case 1:
609 suffix = dirty;
610 break;
611 default:
612 /* diff-index aborted abnormally */
613 suffix = broken;
614 }
615 } else if (dirty) {
616 static struct lock_file index_lock;
617 struct rev_info revs;
618 struct argv_array args = ARGV_ARRAY_INIT;
619 int fd, result;
620
621 read_cache_preload(NULL);
622 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED,
623 NULL, NULL, NULL);
624 fd = hold_locked_index(&index_lock, 0);
625 if (0 <= fd)
626 update_index_if_able(&the_index, &index_lock);
627
628 init_revisions(&revs, prefix);
629 argv_array_pushv(&args, diff_index_args);
630 if (setup_revisions(args.argc, args.argv, &revs, NULL) != 1)
631 BUG("malformed internal diff-index command line");
632 result = run_diff_index(&revs, 0);
633
634 if (!diff_result_code(&revs.diffopt, result))
635 suffix = NULL;
636 else
637 suffix = dirty;
638 }
639 describe("HEAD", 1);
640 } else if (dirty) {
641 die(_("--dirty is incompatible with commit-ishes"));
642 } else if (broken) {
643 die(_("--broken is incompatible with commit-ishes"));
644 } else {
645 while (argc-- > 0)
646 describe(*argv++, argc == 0);
647 }
648 return 0;
649}