1 #define USE_THE_INDEX_VARIABLE
4 #include "environment.h"
13 #include "object-name.h"
14 #include "parse-options.h"
15 #include "read-cache-ll.h"
21 #include "run-command.h"
22 #include "object-store-ll.h"
23 #include "list-objects.h"
24 #include "commit-slab.h"
25 #include "wildmatch.h"
27 #define MAX_TAGS (FLAG_BITS - 1)
28 #define DEFAULT_CANDIDATES 10
30 define_commit_slab(commit_names
, struct commit_name
*);
32 static const char * const describe_usage
[] = {
33 N_("git describe [--all] [--tags] [--contains] [--abbrev=<n>] [<commit-ish>...]"),
34 N_("git describe [--all] [--tags] [--contains] [--abbrev=<n>] --dirty[=<mark>]"),
35 N_("git describe <blob>"),
39 static int debug
; /* Display lots of verbose info */
40 static int all
; /* Any valid ref can be used */
41 static int tags
; /* Allow lightweight tags */
42 static int longformat
;
43 static int first_parent
;
44 static int abbrev
= -1; /* unspecified */
45 static int max_candidates
= DEFAULT_CANDIDATES
;
46 static struct hashmap names
;
48 static struct string_list patterns
= STRING_LIST_INIT_NODUP
;
49 static struct string_list exclude_patterns
= STRING_LIST_INIT_NODUP
;
51 static const char *suffix
, *dirty
, *broken
;
52 static struct commit_names commit_names
;
54 /* diff-index command arguments to check if working tree is dirty. */
55 static const char *diff_index_args
[] = {
56 "diff-index", "--quiet", "HEAD", "--", NULL
60 struct hashmap_entry entry
;
61 struct object_id peeled
;
63 unsigned prio
:2; /* annotated tag = 2, tag = 1, head = 0 */
64 unsigned name_checked
:1;
70 static const char *prio_names
[] = {
71 N_("head"), N_("lightweight"), N_("annotated"),
74 static int commit_name_neq(const void *cmp_data UNUSED
,
75 const struct hashmap_entry
*eptr
,
76 const struct hashmap_entry
*entry_or_key
,
79 const struct commit_name
*cn1
, *cn2
;
81 cn1
= container_of(eptr
, const struct commit_name
, entry
);
82 cn2
= container_of(entry_or_key
, const struct commit_name
, entry
);
84 return !oideq(&cn1
->peeled
, peeled
? peeled
: &cn2
->peeled
);
87 static inline struct commit_name
*find_commit_name(const struct object_id
*peeled
)
89 return hashmap_get_entry_from_hash(&names
, oidhash(peeled
), peeled
,
90 struct commit_name
, entry
);
93 static int replace_name(struct commit_name
*e
,
95 const struct object_id
*oid
,
98 if (!e
|| e
->prio
< prio
)
101 if (e
->prio
== 2 && prio
== 2) {
102 /* Multiple annotated tags point to the same commit.
103 * Select one to keep based upon their tagger date.
108 t
= lookup_tag(the_repository
, &e
->oid
);
109 if (!t
|| parse_tag(t
))
114 t
= lookup_tag(the_repository
, oid
);
115 if (!t
|| parse_tag(t
))
119 if (e
->tag
->date
< t
->date
)
126 static void add_to_known_names(const char *path
,
127 const struct object_id
*peeled
,
129 const struct object_id
*oid
)
131 struct commit_name
*e
= find_commit_name(peeled
);
132 struct tag
*tag
= NULL
;
133 if (replace_name(e
, prio
, oid
, &tag
)) {
135 e
= xmalloc(sizeof(struct commit_name
));
136 oidcpy(&e
->peeled
, peeled
);
137 hashmap_entry_init(&e
->entry
, oidhash(peeled
));
138 hashmap_add(&names
, &e
->entry
);
145 oidcpy(&e
->oid
, oid
);
147 e
->path
= xstrdup(path
);
151 static int get_name(const char *path
, const struct object_id
*oid
,
152 int flag UNUSED
, void *cb_data UNUSED
)
155 struct object_id peeled
;
156 int is_annotated
, prio
;
157 const char *path_to_match
= NULL
;
159 if (skip_prefix(path
, "refs/tags/", &path_to_match
)) {
162 if ((exclude_patterns
.nr
|| patterns
.nr
) &&
163 !skip_prefix(path
, "refs/heads/", &path_to_match
) &&
164 !skip_prefix(path
, "refs/remotes/", &path_to_match
)) {
165 /* Only accept reference of known type if there are match/exclude patterns */
169 /* Reject anything outside refs/tags/ unless --all */
174 * If we're given exclude patterns, first exclude any tag which match
175 * any of the exclude pattern.
177 if (exclude_patterns
.nr
) {
178 struct string_list_item
*item
;
180 for_each_string_list_item(item
, &exclude_patterns
) {
181 if (!wildmatch(item
->string
, path_to_match
, 0))
187 * If we're given patterns, accept only tags which match at least one
192 struct string_list_item
*item
;
194 for_each_string_list_item(item
, &patterns
) {
195 if (!wildmatch(item
->string
, path_to_match
, 0)) {
205 /* Is it annotated? */
206 if (!peel_iterated_oid(oid
, &peeled
)) {
207 is_annotated
= !oideq(oid
, &peeled
);
209 oidcpy(&peeled
, oid
);
214 * By default, we only use annotated tags, but with --tags
215 * we fall back to lightweight ones (even without --tags,
216 * we still remember lightweight ones, only to give hints
217 * in an error message). --all allows any refs to be used.
226 add_to_known_names(all
? path
+ 5 : path
+ 10, &peeled
, prio
, oid
);
230 struct possible_tag
{
231 struct commit_name
*name
;
234 unsigned flag_within
;
237 static int compare_pt(const void *a_
, const void *b_
)
239 struct possible_tag
*a
= (struct possible_tag
*)a_
;
240 struct possible_tag
*b
= (struct possible_tag
*)b_
;
241 if (a
->depth
!= b
->depth
)
242 return a
->depth
- b
->depth
;
243 if (a
->found_order
!= b
->found_order
)
244 return a
->found_order
- b
->found_order
;
248 static unsigned long finish_depth_computation(
249 struct commit_list
**list
,
250 struct possible_tag
*best
)
252 unsigned long seen_commits
= 0;
254 struct commit
*c
= pop_commit(list
);
255 struct commit_list
*parents
= c
->parents
;
257 if (c
->object
.flags
& best
->flag_within
) {
258 struct commit_list
*a
= *list
;
260 struct commit
*i
= a
->item
;
261 if (!(i
->object
.flags
& best
->flag_within
))
270 struct commit
*p
= parents
->item
;
271 repo_parse_commit(the_repository
, p
);
272 if (!(p
->object
.flags
& SEEN
))
273 commit_list_insert_by_date(p
, list
);
274 p
->object
.flags
|= c
->object
.flags
;
275 parents
= parents
->next
;
281 static void append_name(struct commit_name
*n
, struct strbuf
*dst
)
283 if (n
->prio
== 2 && !n
->tag
) {
284 n
->tag
= lookup_tag(the_repository
, &n
->oid
);
285 if (!n
->tag
|| parse_tag(n
->tag
))
286 die(_("annotated tag %s not available"), n
->path
);
288 if (n
->tag
&& !n
->name_checked
) {
289 if (strcmp(n
->tag
->tag
, all
? n
->path
+ 5 : n
->path
)) {
290 warning(_("tag '%s' is externally known as '%s'"),
291 n
->path
, n
->tag
->tag
);
299 strbuf_addstr(dst
, "tags/");
300 strbuf_addstr(dst
, n
->tag
->tag
);
302 strbuf_addstr(dst
, n
->path
);
306 static void append_suffix(int depth
, const struct object_id
*oid
, struct strbuf
*dst
)
308 strbuf_addf(dst
, "-%d-g%s", depth
,
309 repo_find_unique_abbrev(the_repository
, oid
, abbrev
));
312 static void describe_commit(struct object_id
*oid
, struct strbuf
*dst
)
314 struct commit
*cmit
, *gave_up_on
= NULL
;
315 struct commit_list
*list
;
316 struct commit_name
*n
;
317 struct possible_tag all_matches
[MAX_TAGS
];
318 unsigned int match_cnt
= 0, annotated_cnt
= 0, cur_match
;
319 unsigned long seen_commits
= 0;
320 unsigned int unannotated_cnt
= 0;
322 cmit
= lookup_commit_reference(the_repository
, oid
);
324 n
= find_commit_name(&cmit
->object
.oid
);
325 if (n
&& (tags
|| all
|| n
->prio
== 2)) {
327 * Exact match to an existing ref.
330 if (n
->misnamed
|| longformat
)
331 append_suffix(0, n
->tag
? get_tagged_oid(n
->tag
) : oid
, dst
);
333 strbuf_addstr(dst
, suffix
);
338 die(_("no tag exactly matches '%s'"), oid_to_hex(&cmit
->object
.oid
));
340 fprintf(stderr
, _("No exact match on refs or tags, searching to describe\n"));
343 struct hashmap_iter iter
;
345 struct commit_name
*n
;
347 init_commit_names(&commit_names
);
348 hashmap_for_each_entry(&names
, &iter
, n
,
349 entry
/* member name */) {
350 c
= lookup_commit_reference_gently(the_repository
,
353 *commit_names_at(&commit_names
, c
) = n
;
359 cmit
->object
.flags
= SEEN
;
360 commit_list_insert(cmit
, &list
);
362 struct commit
*c
= pop_commit(&list
);
363 struct commit_list
*parents
= c
->parents
;
364 struct commit_name
**slot
;
367 slot
= commit_names_peek(&commit_names
, c
);
368 n
= slot
? *slot
: NULL
;
370 if (!tags
&& !all
&& n
->prio
< 2) {
372 } else if (match_cnt
< max_candidates
) {
373 struct possible_tag
*t
= &all_matches
[match_cnt
++];
375 t
->depth
= seen_commits
- 1;
376 t
->flag_within
= 1u << match_cnt
;
377 t
->found_order
= match_cnt
;
378 c
->object
.flags
|= t
->flag_within
;
387 for (cur_match
= 0; cur_match
< match_cnt
; cur_match
++) {
388 struct possible_tag
*t
= &all_matches
[cur_match
];
389 if (!(c
->object
.flags
& t
->flag_within
))
392 /* Stop if last remaining path already covered by best candidate(s) */
393 if (annotated_cnt
&& !list
) {
394 int best_depth
= INT_MAX
;
395 unsigned best_within
= 0;
396 for (cur_match
= 0; cur_match
< match_cnt
; cur_match
++) {
397 struct possible_tag
*t
= &all_matches
[cur_match
];
398 if (t
->depth
< best_depth
) {
399 best_depth
= t
->depth
;
400 best_within
= t
->flag_within
;
401 } else if (t
->depth
== best_depth
) {
402 best_within
|= t
->flag_within
;
405 if ((c
->object
.flags
& best_within
) == best_within
) {
407 fprintf(stderr
, _("finished search at %s\n"),
408 oid_to_hex(&c
->object
.oid
));
413 struct commit
*p
= parents
->item
;
414 repo_parse_commit(the_repository
, p
);
415 if (!(p
->object
.flags
& SEEN
))
416 commit_list_insert_by_date(p
, &list
);
417 p
->object
.flags
|= c
->object
.flags
;
418 parents
= parents
->next
;
426 struct object_id
*cmit_oid
= &cmit
->object
.oid
;
428 strbuf_add_unique_abbrev(dst
, cmit_oid
, abbrev
);
430 strbuf_addstr(dst
, suffix
);
434 die(_("No annotated tags can describe '%s'.\n"
435 "However, there were unannotated tags: try --tags."),
436 oid_to_hex(cmit_oid
));
438 die(_("No tags can describe '%s'.\n"
439 "Try --always, or create some tags."),
440 oid_to_hex(cmit_oid
));
443 QSORT(all_matches
, match_cnt
, compare_pt
);
446 commit_list_insert_by_date(gave_up_on
, &list
);
449 seen_commits
+= finish_depth_computation(&list
, &all_matches
[0]);
450 free_commit_list(list
);
453 static int label_width
= -1;
454 if (label_width
< 0) {
456 for (i
= 0; i
< ARRAY_SIZE(prio_names
); i
++) {
457 w
= strlen(_(prio_names
[i
]));
462 for (cur_match
= 0; cur_match
< match_cnt
; cur_match
++) {
463 struct possible_tag
*t
= &all_matches
[cur_match
];
464 fprintf(stderr
, " %-*s %8d %s\n",
465 label_width
, _(prio_names
[t
->name
->prio
]),
466 t
->depth
, t
->name
->path
);
468 fprintf(stderr
, _("traversed %lu commits\n"), seen_commits
);
471 _("more than %i tags found; listed %i most recent\n"
472 "gave up search at %s\n"),
473 max_candidates
, max_candidates
,
474 oid_to_hex(&gave_up_on
->object
.oid
));
478 append_name(all_matches
[0].name
, dst
);
479 if (all_matches
[0].name
->misnamed
|| abbrev
)
480 append_suffix(all_matches
[0].depth
, &cmit
->object
.oid
, dst
);
482 strbuf_addstr(dst
, suffix
);
485 struct process_commit_data
{
486 struct object_id current_commit
;
487 struct object_id looking_for
;
489 struct rev_info
*revs
;
492 static void process_commit(struct commit
*commit
, void *data
)
494 struct process_commit_data
*pcd
= data
;
495 pcd
->current_commit
= commit
->object
.oid
;
498 static void process_object(struct object
*obj
, const char *path
, void *data
)
500 struct process_commit_data
*pcd
= data
;
502 if (oideq(&pcd
->looking_for
, &obj
->oid
) && !pcd
->dst
->len
) {
503 reset_revision_walk();
504 describe_commit(&pcd
->current_commit
, pcd
->dst
);
505 strbuf_addf(pcd
->dst
, ":%s", path
);
506 free_commit_list(pcd
->revs
->commits
);
507 pcd
->revs
->commits
= NULL
;
511 static void describe_blob(struct object_id oid
, struct strbuf
*dst
)
513 struct rev_info revs
;
514 struct strvec args
= STRVEC_INIT
;
515 struct process_commit_data pcd
= { *null_oid(), oid
, dst
, &revs
};
517 strvec_pushl(&args
, "internal: The first arg is not parsed",
518 "--objects", "--in-commit-order", "--reverse", "HEAD",
521 repo_init_revisions(the_repository
, &revs
, NULL
);
522 if (setup_revisions(args
.nr
, args
.v
, &revs
, NULL
) > 1)
523 BUG("setup_revisions could not handle all args?");
525 if (prepare_revision_walk(&revs
))
526 die("revision walk setup failed");
528 traverse_commit_list(&revs
, process_commit
, process_object
, &pcd
);
529 reset_revision_walk();
530 release_revisions(&revs
);
533 static void describe(const char *arg
, int last_one
)
535 struct object_id oid
;
537 struct strbuf sb
= STRBUF_INIT
;
540 fprintf(stderr
, _("describe %s\n"), arg
);
542 if (repo_get_oid(the_repository
, arg
, &oid
))
543 die(_("Not a valid object name %s"), arg
);
544 cmit
= lookup_commit_reference_gently(the_repository
, &oid
, 1);
547 describe_commit(&oid
, &sb
);
548 else if (oid_object_info(the_repository
, &oid
, NULL
) == OBJ_BLOB
)
549 describe_blob(oid
, &sb
);
551 die(_("%s is neither a commit nor blob"), arg
);
556 clear_commit_marks(cmit
, -1);
561 static int option_parse_exact_match(const struct option
*opt
, const char *arg
,
564 int *val
= opt
->value
;
568 *val
= unset
? DEFAULT_CANDIDATES
: 0;
572 int cmd_describe(int argc
, const char **argv
, const char *prefix
)
575 struct option options
[] = {
576 OPT_BOOL(0, "contains", &contains
, N_("find the tag that comes after the commit")),
577 OPT_BOOL(0, "debug", &debug
, N_("debug search strategy on stderr")),
578 OPT_BOOL(0, "all", &all
, N_("use any ref")),
579 OPT_BOOL(0, "tags", &tags
, N_("use any tag, even unannotated")),
580 OPT_BOOL(0, "long", &longformat
, N_("always use long format")),
581 OPT_BOOL(0, "first-parent", &first_parent
, N_("only follow first parent")),
582 OPT__ABBREV(&abbrev
),
583 OPT_CALLBACK_F(0, "exact-match", &max_candidates
, NULL
,
584 N_("only output exact matches"),
585 PARSE_OPT_NOARG
, option_parse_exact_match
),
586 OPT_INTEGER(0, "candidates", &max_candidates
,
587 N_("consider <n> most recent tags (default: 10)")),
588 OPT_STRING_LIST(0, "match", &patterns
, N_("pattern"),
589 N_("only consider tags matching <pattern>")),
590 OPT_STRING_LIST(0, "exclude", &exclude_patterns
, N_("pattern"),
591 N_("do not consider tags matching <pattern>")),
592 OPT_BOOL(0, "always", &always
,
593 N_("show abbreviated commit object as fallback")),
594 {OPTION_STRING
, 0, "dirty", &dirty
, N_("mark"),
595 N_("append <mark> on dirty working tree (default: \"-dirty\")"),
596 PARSE_OPT_OPTARG
, NULL
, (intptr_t) "-dirty"},
597 {OPTION_STRING
, 0, "broken", &broken
, N_("mark"),
598 N_("append <mark> on broken working tree (default: \"-broken\")"),
599 PARSE_OPT_OPTARG
, NULL
, (intptr_t) "-broken"},
603 git_config(git_default_config
, NULL
);
604 argc
= parse_options(argc
, argv
, prefix
, options
, describe_usage
, 0);
606 abbrev
= DEFAULT_ABBREV
;
608 if (max_candidates
< 0)
610 else if (max_candidates
> MAX_TAGS
)
611 max_candidates
= MAX_TAGS
;
613 save_commit_buffer
= 0;
615 if (longformat
&& abbrev
== 0)
616 die(_("options '%s' and '%s' cannot be used together"), "--long", "--abbrev=0");
619 struct string_list_item
*item
;
623 strvec_pushl(&args
, "name-rev",
624 "--peel-tag", "--name-only", "--no-undefined",
627 strvec_push(&args
, "--always");
629 strvec_push(&args
, "--tags");
630 for_each_string_list_item(item
, &patterns
)
631 strvec_pushf(&args
, "--refs=refs/tags/%s", item
->string
);
632 for_each_string_list_item(item
, &exclude_patterns
)
633 strvec_pushf(&args
, "--exclude=refs/tags/%s", item
->string
);
636 strvec_pushv(&args
, argv
);
638 strvec_push(&args
, "HEAD");
639 return cmd_name_rev(args
.nr
, args
.v
, prefix
);
642 hashmap_init(&names
, commit_name_neq
, NULL
, 0);
643 for_each_rawref(get_name
, NULL
);
644 if (!hashmap_get_size(&names
) && !always
)
645 die(_("No names found, cannot describe anything."));
649 struct child_process cp
= CHILD_PROCESS_INIT
;
650 strvec_pushv(&cp
.args
, diff_index_args
);
658 switch (run_command(&cp
)) {
666 /* diff-index aborted abnormally */
670 struct lock_file index_lock
= LOCK_INIT
;
671 struct rev_info revs
;
672 struct strvec args
= STRVEC_INIT
;
676 prepare_repo_settings(the_repository
);
677 the_repository
->settings
.command_requires_full_index
= 0;
678 repo_read_index(the_repository
);
679 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
,
681 fd
= repo_hold_locked_index(the_repository
,
684 repo_update_index_if_able(the_repository
, &index_lock
);
686 repo_init_revisions(the_repository
, &revs
, prefix
);
687 strvec_pushv(&args
, diff_index_args
);
688 if (setup_revisions(args
.nr
, args
.v
, &revs
, NULL
) != 1)
689 BUG("malformed internal diff-index command line");
690 run_diff_index(&revs
, 0);
692 if (!diff_result_code(&revs
.diffopt
))
696 release_revisions(&revs
);
700 die(_("option '%s' and commit-ishes cannot be used together"), "--dirty");
702 die(_("option '%s' and commit-ishes cannot be used together"), "--broken");
705 describe(*argv
++, argc
== 0);