10 #include "parse-options.h"
14 #include "argv-array.h"
15 #include "run-command.h"
16 #include "object-store.h"
18 #include "list-objects.h"
20 #define MAX_TAGS (FLAG_BITS - 1)
22 static const char * const describe_usage
[] = {
23 N_("git describe [<options>] [<commit-ish>...]"),
24 N_("git describe [<options>] --dirty"),
28 static int debug
; /* Display lots of verbose info */
29 static int all
; /* Any valid ref can be used */
30 static int tags
; /* Allow lightweight tags */
31 static int longformat
;
32 static int first_parent
;
33 static int abbrev
= -1; /* unspecified */
34 static int max_candidates
= 10;
35 static struct hashmap names
;
37 static struct string_list patterns
= STRING_LIST_INIT_NODUP
;
38 static struct string_list exclude_patterns
= STRING_LIST_INIT_NODUP
;
40 static const char *suffix
, *dirty
, *broken
;
42 /* diff-index command arguments to check if working tree is dirty. */
43 static const char *diff_index_args
[] = {
44 "diff-index", "--quiet", "HEAD", "--", NULL
48 struct hashmap_entry entry
;
49 struct object_id peeled
;
51 unsigned prio
:2; /* annotated tag = 2, tag = 1, head = 0 */
52 unsigned name_checked
:1;
57 static const char *prio_names
[] = {
58 N_("head"), N_("lightweight"), N_("annotated"),
61 static int commit_name_cmp(const void *unused_cmp_data
,
63 const void *entry_or_key
,
66 const struct commit_name
*cn1
= entry
;
67 const struct commit_name
*cn2
= entry_or_key
;
69 return oidcmp(&cn1
->peeled
, peeled
? peeled
: &cn2
->peeled
);
72 static inline struct commit_name
*find_commit_name(const struct object_id
*peeled
)
74 return hashmap_get_from_hash(&names
, sha1hash(peeled
->hash
), peeled
->hash
);
77 static int replace_name(struct commit_name
*e
,
79 const struct object_id
*oid
,
82 if (!e
|| e
->prio
< prio
)
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.
92 t
= lookup_tag(&e
->oid
);
93 if (!t
|| parse_tag(t
))
99 if (!t
|| parse_tag(t
))
103 if (e
->tag
->date
< t
->date
)
110 static void add_to_known_names(const char *path
,
111 const struct object_id
*peeled
,
113 const struct object_id
*oid
)
115 struct commit_name
*e
= find_commit_name(peeled
);
116 struct tag
*tag
= NULL
;
117 if (replace_name(e
, prio
, oid
, &tag
)) {
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
);
128 oidcpy(&e
->oid
, oid
);
130 e
->path
= xstrdup(path
);
134 static int get_name(const char *path
, const struct object_id
*oid
, int flag
, void *cb_data
)
137 struct object_id peeled
;
138 int is_annotated
, prio
;
139 const char *path_to_match
= NULL
;
141 if (skip_prefix(path
, "refs/tags/", &path_to_match
)) {
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 */
151 /* Reject anything outside refs/tags/ unless --all */
156 * If we're given exclude patterns, first exclude any tag which match
157 * any of the exclude pattern.
159 if (exclude_patterns
.nr
) {
160 struct string_list_item
*item
;
162 for_each_string_list_item(item
, &exclude_patterns
) {
163 if (!wildmatch(item
->string
, path_to_match
, 0))
169 * If we're given patterns, accept only tags which match at least one
174 struct string_list_item
*item
;
176 for_each_string_list_item(item
, &patterns
) {
177 if (!wildmatch(item
->string
, path_to_match
, 0)) {
187 /* Is it annotated? */
188 if (!peel_ref(path
, &peeled
)) {
189 is_annotated
= !!oidcmp(oid
, &peeled
);
191 oidcpy(&peeled
, oid
);
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.
208 add_to_known_names(all
? path
+ 5 : path
+ 10, &peeled
, prio
, oid
);
212 struct possible_tag
{
213 struct commit_name
*name
;
216 unsigned flag_within
;
219 static int compare_pt(const void *a_
, const void *b_
)
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
;
230 static unsigned long finish_depth_computation(
231 struct commit_list
**list
,
232 struct possible_tag
*best
)
234 unsigned long seen_commits
= 0;
236 struct commit
*c
= pop_commit(list
);
237 struct commit_list
*parents
= c
->parents
;
239 if (c
->object
.flags
& best
->flag_within
) {
240 struct commit_list
*a
= *list
;
242 struct commit
*i
= a
->item
;
243 if (!(i
->object
.flags
& best
->flag_within
))
252 struct commit
*p
= parents
->item
;
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
;
263 static void append_name(struct commit_name
*n
, struct strbuf
*dst
)
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
);
270 if (n
->tag
&& !n
->name_checked
) {
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
);
280 strbuf_addstr(dst
, "tags/");
281 strbuf_addstr(dst
, n
->tag
->tag
);
283 strbuf_addstr(dst
, n
->path
);
287 static void append_suffix(int depth
, const struct object_id
*oid
, struct strbuf
*dst
)
289 strbuf_addf(dst
, "-%d-g%s", depth
, find_unique_abbrev(oid
, abbrev
));
292 static void describe_commit(struct object_id
*oid
, struct strbuf
*dst
)
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;
302 cmit
= lookup_commit_reference(oid
);
304 n
= find_commit_name(&cmit
->object
.oid
);
305 if (n
&& (tags
|| all
|| n
->prio
== 2)) {
307 * Exact match to an existing ref.
311 append_suffix(0, n
->tag
? &n
->tag
->tagged
->oid
: oid
, dst
);
313 strbuf_addstr(dst
, suffix
);
318 die(_("no tag exactly matches '%s'"), oid_to_hex(&cmit
->object
.oid
));
320 fprintf(stderr
, _("No exact match on refs or tags, searching to describe\n"));
323 struct hashmap_iter iter
;
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);
335 cmit
->object
.flags
= SEEN
;
336 commit_list_insert(cmit
, &list
);
338 struct commit
*c
= pop_commit(&list
);
339 struct commit_list
*parents
= c
->parents
;
343 if (!tags
&& !all
&& n
->prio
< 2) {
345 } else if (match_cnt
< max_candidates
) {
346 struct possible_tag
*t
= &all_matches
[match_cnt
++];
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
;
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
))
365 if (annotated_cnt
&& !list
) {
367 fprintf(stderr
, _("finished search at %s\n"),
368 oid_to_hex(&c
->object
.oid
));
372 struct commit
*p
= parents
->item
;
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
;
385 struct object_id
*cmit_oid
= &cmit
->object
.oid
;
387 strbuf_add_unique_abbrev(dst
, cmit_oid
, abbrev
);
389 strbuf_addstr(dst
, suffix
);
393 die(_("No annotated tags can describe '%s'.\n"
394 "However, there were unannotated tags: try --tags."),
395 oid_to_hex(cmit_oid
));
397 die(_("No tags can describe '%s'.\n"
398 "Try --always, or create some tags."),
399 oid_to_hex(cmit_oid
));
402 QSORT(all_matches
, match_cnt
, compare_pt
);
405 commit_list_insert_by_date(gave_up_on
, &list
);
408 seen_commits
+= finish_depth_computation(&list
, &all_matches
[0]);
409 free_commit_list(list
);
412 static int label_width
= -1;
413 if (label_width
< 0) {
415 for (i
= 0; i
< ARRAY_SIZE(prio_names
); i
++) {
416 w
= strlen(_(prio_names
[i
]));
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
);
427 fprintf(stderr
, _("traversed %lu commits\n"), seen_commits
);
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
));
437 append_name(all_matches
[0].name
, dst
);
439 append_suffix(all_matches
[0].depth
, &cmit
->object
.oid
, dst
);
441 strbuf_addstr(dst
, suffix
);
444 struct process_commit_data
{
445 struct object_id current_commit
;
446 struct object_id looking_for
;
448 struct rev_info
*revs
;
451 static void process_commit(struct commit
*commit
, void *data
)
453 struct process_commit_data
*pcd
= data
;
454 pcd
->current_commit
= commit
->object
.oid
;
457 static void process_object(struct object
*obj
, const char *path
, void *data
)
459 struct process_commit_data
*pcd
= data
;
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
;
470 static void describe_blob(struct object_id oid
, struct strbuf
*dst
)
472 struct rev_info revs
;
473 struct argv_array args
= ARGV_ARRAY_INIT
;
474 struct process_commit_data pcd
= { null_oid
, oid
, dst
, &revs
};
476 argv_array_pushl(&args
, "internal: The first arg is not parsed",
477 "--objects", "--in-commit-order", "--reverse", "HEAD",
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?");
484 if (prepare_revision_walk(&revs
))
485 die("revision walk setup failed");
487 traverse_commit_list(&revs
, process_commit
, process_object
, &pcd
);
488 reset_revision_walk();
491 static void describe(const char *arg
, int last_one
)
493 struct object_id oid
;
495 struct strbuf sb
= STRBUF_INIT
;
498 fprintf(stderr
, _("describe %s\n"), arg
);
500 if (get_oid(arg
, &oid
))
501 die(_("Not a valid object name %s"), arg
);
502 cmit
= lookup_commit_reference_gently(&oid
, 1);
505 describe_commit(&oid
, &sb
);
506 else if (oid_object_info(the_repository
, &oid
, NULL
) == OBJ_BLOB
)
507 describe_blob(oid
, &sb
);
509 die(_("%s is neither a commit nor blob"), arg
);
514 clear_commit_marks(cmit
, -1);
519 int cmd_describe(int argc
, const char **argv
, const char *prefix
)
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"},
549 git_config(git_default_config
, NULL
);
550 argc
= parse_options(argc
, argv
, prefix
, options
, describe_usage
, 0);
552 abbrev
= DEFAULT_ABBREV
;
554 if (max_candidates
< 0)
556 else if (max_candidates
> MAX_TAGS
)
557 max_candidates
= MAX_TAGS
;
559 save_commit_buffer
= 0;
561 if (longformat
&& abbrev
== 0)
562 die(_("--long is incompatible with --abbrev=0"));
565 struct string_list_item
*item
;
566 struct argv_array args
;
568 argv_array_init(&args
);
569 argv_array_pushl(&args
, "name-rev",
570 "--peel-tag", "--name-only", "--no-undefined",
573 argv_array_push(&args
, "--always");
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
);
582 argv_array_pushv(&args
, argv
);
584 argv_array_push(&args
, "HEAD");
585 return cmd_name_rev(args
.argc
, args
.argv
, prefix
);
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."));
595 struct child_process cp
= CHILD_PROCESS_INIT
;
596 argv_array_pushv(&cp
.args
, diff_index_args
);
604 switch (run_command(&cp
)) {
612 /* diff-index aborted abnormally */
616 static struct lock_file index_lock
;
617 struct rev_info revs
;
618 struct argv_array args
= ARGV_ARRAY_INIT
;
621 read_cache_preload(NULL
);
622 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
,
624 fd
= hold_locked_index(&index_lock
, 0);
626 update_index_if_able(&the_index
, &index_lock
);
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);
634 if (!diff_result_code(&revs
.diffopt
, result
))
641 die(_("--dirty is incompatible with commit-ishes"));
643 die(_("--broken is incompatible with commit-ishes"));
646 describe(*argv
++, argc
== 0);