commit: Add commit_list prefix in two function names.
[git/git.git] / builtin / describe.c
1 #include "cache.h"
2 #include "commit.h"
3 #include "tag.h"
4 #include "refs.h"
5 #include "builtin.h"
6 #include "exec_cmd.h"
7 #include "parse-options.h"
8 #include "diff.h"
9
10 #define SEEN (1u<<0)
11 #define MAX_TAGS (FLAG_BITS - 1)
12
13 static const char * const describe_usage[] = {
14 "git describe [options] <committish>*",
15 "git describe [options] --dirty",
16 NULL
17 };
18
19 static int debug; /* Display lots of verbose info */
20 static int all; /* Any valid ref can be used */
21 static int tags; /* Allow lightweight tags */
22 static int longformat;
23 static int abbrev = DEFAULT_ABBREV;
24 static int max_candidates = 10;
25 static int found_names;
26 static const char *pattern;
27 static int always;
28 static const char *dirty;
29
30 /* diff-index command arguments to check if working tree is dirty. */
31 static const char *diff_index_args[] = {
32 "diff-index", "--quiet", "HEAD", "--", NULL
33 };
34
35
36 struct commit_name {
37 struct tag *tag;
38 unsigned prio:2; /* annotated tag = 2, tag = 1, head = 0 */
39 unsigned name_checked:1;
40 unsigned char sha1[20];
41 char path[FLEX_ARRAY]; /* more */
42 };
43 static const char *prio_names[] = {
44 "head", "lightweight", "annotated",
45 };
46
47 static int replace_name(struct commit_name *e,
48 int prio,
49 const unsigned char *sha1,
50 struct tag **tag)
51 {
52 if (!e || e->prio < prio)
53 return 1;
54
55 if (e->prio == 2 && prio == 2) {
56 /* Multiple annotated tags point to the same commit.
57 * Select one to keep based upon their tagger date.
58 */
59 struct tag *t;
60
61 if (!e->tag) {
62 t = lookup_tag(e->sha1);
63 if (!t || parse_tag(t))
64 return 1;
65 e->tag = t;
66 }
67
68 t = lookup_tag(sha1);
69 if (!t || parse_tag(t))
70 return 0;
71 *tag = t;
72
73 if (e->tag->date < t->date)
74 return 1;
75 }
76
77 return 0;
78 }
79
80 static void add_to_known_names(const char *path,
81 struct commit *commit,
82 int prio,
83 const unsigned char *sha1)
84 {
85 struct commit_name *e = commit->util;
86 struct tag *tag = NULL;
87 if (replace_name(e, prio, sha1, &tag)) {
88 size_t len = strlen(path)+1;
89 free(e);
90 e = xmalloc(sizeof(struct commit_name) + len);
91 e->tag = tag;
92 e->prio = prio;
93 e->name_checked = 0;
94 hashcpy(e->sha1, sha1);
95 memcpy(e->path, path, len);
96 commit->util = e;
97 }
98 found_names = 1;
99 }
100
101 static int get_name(const char *path, const unsigned char *sha1, int flag, void *cb_data)
102 {
103 int might_be_tag = !prefixcmp(path, "refs/tags/");
104 struct commit *commit;
105 struct object *object;
106 unsigned char peeled[20];
107 int is_tag, prio;
108
109 if (!all && !might_be_tag)
110 return 0;
111
112 if (!peel_ref(path, peeled) && !is_null_sha1(peeled)) {
113 commit = lookup_commit_reference_gently(peeled, 1);
114 if (!commit)
115 return 0;
116 is_tag = !!hashcmp(sha1, commit->object.sha1);
117 } else {
118 commit = lookup_commit_reference_gently(sha1, 1);
119 object = parse_object(sha1);
120 if (!commit || !object)
121 return 0;
122 is_tag = object->type == OBJ_TAG;
123 }
124
125 /* If --all, then any refs are used.
126 * If --tags, then any tags are used.
127 * Otherwise only annotated tags are used.
128 */
129 if (might_be_tag) {
130 if (is_tag)
131 prio = 2;
132 else
133 prio = 1;
134
135 if (pattern && fnmatch(pattern, path + 10, 0))
136 prio = 0;
137 }
138 else
139 prio = 0;
140
141 if (!all) {
142 if (!prio)
143 return 0;
144 }
145 add_to_known_names(all ? path + 5 : path + 10, commit, prio, sha1);
146 return 0;
147 }
148
149 struct possible_tag {
150 struct commit_name *name;
151 int depth;
152 int found_order;
153 unsigned flag_within;
154 };
155
156 static int compare_pt(const void *a_, const void *b_)
157 {
158 struct possible_tag *a = (struct possible_tag *)a_;
159 struct possible_tag *b = (struct possible_tag *)b_;
160 if (a->depth != b->depth)
161 return a->depth - b->depth;
162 if (a->found_order != b->found_order)
163 return a->found_order - b->found_order;
164 return 0;
165 }
166
167 static unsigned long finish_depth_computation(
168 struct commit_list **list,
169 struct possible_tag *best)
170 {
171 unsigned long seen_commits = 0;
172 while (*list) {
173 struct commit *c = pop_commit(list);
174 struct commit_list *parents = c->parents;
175 seen_commits++;
176 if (c->object.flags & best->flag_within) {
177 struct commit_list *a = *list;
178 while (a) {
179 struct commit *i = a->item;
180 if (!(i->object.flags & best->flag_within))
181 break;
182 a = a->next;
183 }
184 if (!a)
185 break;
186 } else
187 best->depth++;
188 while (parents) {
189 struct commit *p = parents->item;
190 parse_commit(p);
191 if (!(p->object.flags & SEEN))
192 commit_list_insert_by_date(p, list);
193 p->object.flags |= c->object.flags;
194 parents = parents->next;
195 }
196 }
197 return seen_commits;
198 }
199
200 static void display_name(struct commit_name *n)
201 {
202 if (n->prio == 2 && !n->tag) {
203 n->tag = lookup_tag(n->sha1);
204 if (!n->tag || parse_tag(n->tag))
205 die("annotated tag %s not available", n->path);
206 }
207 if (n->tag && !n->name_checked) {
208 if (!n->tag->tag)
209 die("annotated tag %s has no embedded name", n->path);
210 if (strcmp(n->tag->tag, all ? n->path + 5 : n->path))
211 warning("tag '%s' is really '%s' here", n->tag->tag, n->path);
212 n->name_checked = 1;
213 }
214
215 if (n->tag)
216 printf("%s", n->tag->tag);
217 else
218 printf("%s", n->path);
219 }
220
221 static void show_suffix(int depth, const unsigned char *sha1)
222 {
223 printf("-%d-g%s", depth, find_unique_abbrev(sha1, abbrev));
224 }
225
226 static void describe(const char *arg, int last_one)
227 {
228 unsigned char sha1[20];
229 struct commit *cmit, *gave_up_on = NULL;
230 struct commit_list *list;
231 struct commit_name *n;
232 struct possible_tag all_matches[MAX_TAGS];
233 unsigned int match_cnt = 0, annotated_cnt = 0, cur_match;
234 unsigned long seen_commits = 0;
235 unsigned int unannotated_cnt = 0;
236
237 if (get_sha1(arg, sha1))
238 die("Not a valid object name %s", arg);
239 cmit = lookup_commit_reference(sha1);
240 if (!cmit)
241 die("%s is not a valid '%s' object", arg, commit_type);
242
243 n = cmit->util;
244 if (n && (tags || all || n->prio == 2)) {
245 /*
246 * Exact match to an existing ref.
247 */
248 display_name(n);
249 if (longformat)
250 show_suffix(0, n->tag ? n->tag->tagged->sha1 : sha1);
251 if (dirty)
252 printf("%s", dirty);
253 printf("\n");
254 return;
255 }
256
257 if (!max_candidates)
258 die("no tag exactly matches '%s'", sha1_to_hex(cmit->object.sha1));
259 if (debug)
260 fprintf(stderr, "searching to describe %s\n", arg);
261
262 list = NULL;
263 cmit->object.flags = SEEN;
264 commit_list_insert(cmit, &list);
265 while (list) {
266 struct commit *c = pop_commit(&list);
267 struct commit_list *parents = c->parents;
268 seen_commits++;
269 n = c->util;
270 if (n) {
271 if (!tags && !all && n->prio < 2) {
272 unannotated_cnt++;
273 } else if (match_cnt < max_candidates) {
274 struct possible_tag *t = &all_matches[match_cnt++];
275 t->name = n;
276 t->depth = seen_commits - 1;
277 t->flag_within = 1u << match_cnt;
278 t->found_order = match_cnt;
279 c->object.flags |= t->flag_within;
280 if (n->prio == 2)
281 annotated_cnt++;
282 }
283 else {
284 gave_up_on = c;
285 break;
286 }
287 }
288 for (cur_match = 0; cur_match < match_cnt; cur_match++) {
289 struct possible_tag *t = &all_matches[cur_match];
290 if (!(c->object.flags & t->flag_within))
291 t->depth++;
292 }
293 if (annotated_cnt && !list) {
294 if (debug)
295 fprintf(stderr, "finished search at %s\n",
296 sha1_to_hex(c->object.sha1));
297 break;
298 }
299 while (parents) {
300 struct commit *p = parents->item;
301 parse_commit(p);
302 if (!(p->object.flags & SEEN))
303 commit_list_insert_by_date(p, &list);
304 p->object.flags |= c->object.flags;
305 parents = parents->next;
306 }
307 }
308
309 if (!match_cnt) {
310 const unsigned char *sha1 = cmit->object.sha1;
311 if (always) {
312 printf("%s", find_unique_abbrev(sha1, abbrev));
313 if (dirty)
314 printf("%s", dirty);
315 printf("\n");
316 return;
317 }
318 if (unannotated_cnt)
319 die("No annotated tags can describe '%s'.\n"
320 "However, there were unannotated tags: try --tags.",
321 sha1_to_hex(sha1));
322 else
323 die("No tags can describe '%s'.\n"
324 "Try --always, or create some tags.",
325 sha1_to_hex(sha1));
326 }
327
328 qsort(all_matches, match_cnt, sizeof(all_matches[0]), compare_pt);
329
330 if (gave_up_on) {
331 commit_list_insert_by_date(gave_up_on, &list);
332 seen_commits--;
333 }
334 seen_commits += finish_depth_computation(&list, &all_matches[0]);
335 free_commit_list(list);
336
337 if (debug) {
338 for (cur_match = 0; cur_match < match_cnt; cur_match++) {
339 struct possible_tag *t = &all_matches[cur_match];
340 fprintf(stderr, " %-11s %8d %s\n",
341 prio_names[t->name->prio],
342 t->depth, t->name->path);
343 }
344 fprintf(stderr, "traversed %lu commits\n", seen_commits);
345 if (gave_up_on) {
346 fprintf(stderr,
347 "more than %i tags found; listed %i most recent\n"
348 "gave up search at %s\n",
349 max_candidates, max_candidates,
350 sha1_to_hex(gave_up_on->object.sha1));
351 }
352 }
353
354 display_name(all_matches[0].name);
355 if (abbrev)
356 show_suffix(all_matches[0].depth, cmit->object.sha1);
357 if (dirty)
358 printf("%s", dirty);
359 printf("\n");
360
361 if (!last_one)
362 clear_commit_marks(cmit, -1);
363 }
364
365 int cmd_describe(int argc, const char **argv, const char *prefix)
366 {
367 int contains = 0;
368 struct option options[] = {
369 OPT_BOOLEAN(0, "contains", &contains, "find the tag that comes after the commit"),
370 OPT_BOOLEAN(0, "debug", &debug, "debug search strategy on stderr"),
371 OPT_BOOLEAN(0, "all", &all, "use any ref in .git/refs"),
372 OPT_BOOLEAN(0, "tags", &tags, "use any tag in .git/refs/tags"),
373 OPT_BOOLEAN(0, "long", &longformat, "always use long format"),
374 OPT__ABBREV(&abbrev),
375 OPT_SET_INT(0, "exact-match", &max_candidates,
376 "only output exact matches", 0),
377 OPT_INTEGER(0, "candidates", &max_candidates,
378 "consider <n> most recent tags (default: 10)"),
379 OPT_STRING(0, "match", &pattern, "pattern",
380 "only consider tags matching <pattern>"),
381 OPT_BOOLEAN(0, "always", &always,
382 "show abbreviated commit object as fallback"),
383 {OPTION_STRING, 0, "dirty", &dirty, "mark",
384 "append <mark> on dirty working tree (default: \"-dirty\")",
385 PARSE_OPT_OPTARG, NULL, (intptr_t) "-dirty"},
386 OPT_END(),
387 };
388
389 argc = parse_options(argc, argv, prefix, options, describe_usage, 0);
390 if (max_candidates < 0)
391 max_candidates = 0;
392 else if (max_candidates > MAX_TAGS)
393 max_candidates = MAX_TAGS;
394
395 save_commit_buffer = 0;
396
397 if (longformat && abbrev == 0)
398 die("--long is incompatible with --abbrev=0");
399
400 if (contains) {
401 const char **args = xmalloc((7 + argc) * sizeof(char *));
402 int i = 0;
403 args[i++] = "name-rev";
404 args[i++] = "--name-only";
405 args[i++] = "--no-undefined";
406 if (always)
407 args[i++] = "--always";
408 if (!all) {
409 args[i++] = "--tags";
410 if (pattern) {
411 char *s = xmalloc(strlen("--refs=refs/tags/") + strlen(pattern) + 1);
412 sprintf(s, "--refs=refs/tags/%s", pattern);
413 args[i++] = s;
414 }
415 }
416 memcpy(args + i, argv, argc * sizeof(char *));
417 args[i + argc] = NULL;
418 return cmd_name_rev(i + argc, args, prefix);
419 }
420
421 for_each_ref(get_name, NULL);
422 if (!found_names && !always)
423 die("No names found, cannot describe anything.");
424
425 if (argc == 0) {
426 if (dirty && !cmd_diff_index(ARRAY_SIZE(diff_index_args) - 1, diff_index_args, prefix))
427 dirty = NULL;
428 describe("HEAD", 1);
429 } else if (dirty) {
430 die("--dirty is incompatible with committishes");
431 } else {
432 while (argc-- > 0) {
433 describe(*argv++, argc == 0);
434 }
435 }
436 return 0;
437 }