name-rev: drop unused parameters from is_better_name()
[git/git.git] / builtin / name-rev.c
1 #include "builtin.h"
2 #include "cache.h"
3 #include "repository.h"
4 #include "config.h"
5 #include "commit.h"
6 #include "tag.h"
7 #include "refs.h"
8 #include "parse-options.h"
9 #include "sha1-lookup.h"
10 #include "commit-slab.h"
11
12 #define CUTOFF_DATE_SLOP 86400 /* one day */
13
14 typedef struct rev_name {
15 const char *tip_name;
16 timestamp_t taggerdate;
17 int generation;
18 int distance;
19 int from_tag;
20 } rev_name;
21
22 define_commit_slab(commit_rev_name, struct rev_name *);
23
24 static timestamp_t cutoff = TIME_MAX;
25 static struct commit_rev_name rev_names;
26
27 /* How many generations are maximally preferred over _one_ merge traversal? */
28 #define MERGE_TRAVERSAL_WEIGHT 65535
29
30 static struct rev_name *get_commit_rev_name(struct commit *commit)
31 {
32 struct rev_name **slot = commit_rev_name_peek(&rev_names, commit);
33
34 return slot ? *slot : NULL;
35 }
36
37 static void set_commit_rev_name(struct commit *commit, struct rev_name *name)
38 {
39 *commit_rev_name_at(&rev_names, commit) = name;
40 }
41
42 static int is_better_name(struct rev_name *name,
43 timestamp_t taggerdate,
44 int distance,
45 int from_tag)
46 {
47 /*
48 * When comparing names based on tags, prefer names
49 * based on the older tag, even if it is farther away.
50 */
51 if (from_tag && name->from_tag)
52 return (name->taggerdate > taggerdate ||
53 (name->taggerdate == taggerdate &&
54 name->distance > distance));
55
56 /*
57 * We know that at least one of them is a non-tag at this point.
58 * favor a tag over a non-tag.
59 */
60 if (name->from_tag != from_tag)
61 return from_tag;
62
63 /*
64 * We are now looking at two non-tags. Tiebreak to favor
65 * shorter hops.
66 */
67 if (name->distance != distance)
68 return name->distance > distance;
69
70 /* ... or tiebreak to favor older date */
71 if (name->taggerdate != taggerdate)
72 return name->taggerdate > taggerdate;
73
74 /* keep the current one if we cannot decide */
75 return 0;
76 }
77
78 static void name_rev(struct commit *commit,
79 const char *tip_name, timestamp_t taggerdate,
80 int generation, int distance, int from_tag,
81 int deref)
82 {
83 struct rev_name *name = get_commit_rev_name(commit);
84 struct commit_list *parents;
85 int parent_number = 1;
86 char *to_free = NULL;
87
88 parse_commit(commit);
89
90 if (commit->date < cutoff)
91 return;
92
93 if (deref) {
94 tip_name = to_free = xstrfmt("%s^0", tip_name);
95
96 if (generation)
97 die("generation: %d, but deref?", generation);
98 }
99
100 if (name == NULL) {
101 name = xmalloc(sizeof(rev_name));
102 set_commit_rev_name(commit, name);
103 goto copy_data;
104 } else if (is_better_name(name, taggerdate, distance, from_tag)) {
105 copy_data:
106 name->tip_name = tip_name;
107 name->taggerdate = taggerdate;
108 name->generation = generation;
109 name->distance = distance;
110 name->from_tag = from_tag;
111 } else {
112 free(to_free);
113 return;
114 }
115
116 for (parents = commit->parents;
117 parents;
118 parents = parents->next, parent_number++) {
119 if (parent_number > 1) {
120 size_t len;
121 char *new_name;
122
123 strip_suffix(tip_name, "^0", &len);
124 if (generation > 0)
125 new_name = xstrfmt("%.*s~%d^%d", (int)len, tip_name,
126 generation, parent_number);
127 else
128 new_name = xstrfmt("%.*s^%d", (int)len, tip_name,
129 parent_number);
130
131 name_rev(parents->item, new_name, taggerdate, 0,
132 distance + MERGE_TRAVERSAL_WEIGHT,
133 from_tag, 0);
134 } else {
135 name_rev(parents->item, tip_name, taggerdate,
136 generation + 1, distance + 1,
137 from_tag, 0);
138 }
139 }
140 }
141
142 static int subpath_matches(const char *path, const char *filter)
143 {
144 const char *subpath = path;
145
146 while (subpath) {
147 if (!wildmatch(filter, subpath, 0))
148 return subpath - path;
149 subpath = strchr(subpath, '/');
150 if (subpath)
151 subpath++;
152 }
153 return -1;
154 }
155
156 static const char *name_ref_abbrev(const char *refname, int shorten_unambiguous)
157 {
158 if (shorten_unambiguous)
159 refname = shorten_unambiguous_ref(refname, 0);
160 else if (starts_with(refname, "refs/heads/"))
161 refname = refname + 11;
162 else if (starts_with(refname, "refs/"))
163 refname = refname + 5;
164 return refname;
165 }
166
167 struct name_ref_data {
168 int tags_only;
169 int name_only;
170 struct string_list ref_filters;
171 struct string_list exclude_filters;
172 };
173
174 static struct tip_table {
175 struct tip_table_entry {
176 struct object_id oid;
177 const char *refname;
178 } *table;
179 int nr;
180 int alloc;
181 int sorted;
182 } tip_table;
183
184 static void add_to_tip_table(const struct object_id *oid, const char *refname,
185 int shorten_unambiguous)
186 {
187 refname = name_ref_abbrev(refname, shorten_unambiguous);
188
189 ALLOC_GROW(tip_table.table, tip_table.nr + 1, tip_table.alloc);
190 oidcpy(&tip_table.table[tip_table.nr].oid, oid);
191 tip_table.table[tip_table.nr].refname = xstrdup(refname);
192 tip_table.nr++;
193 tip_table.sorted = 0;
194 }
195
196 static int tipcmp(const void *a_, const void *b_)
197 {
198 const struct tip_table_entry *a = a_, *b = b_;
199 return oidcmp(&a->oid, &b->oid);
200 }
201
202 static int name_ref(const char *path, const struct object_id *oid, int flags, void *cb_data)
203 {
204 struct object *o = parse_object(the_repository, oid);
205 struct name_ref_data *data = cb_data;
206 int can_abbreviate_output = data->tags_only && data->name_only;
207 int deref = 0;
208 timestamp_t taggerdate = TIME_MAX;
209
210 if (data->tags_only && !starts_with(path, "refs/tags/"))
211 return 0;
212
213 if (data->exclude_filters.nr) {
214 struct string_list_item *item;
215
216 for_each_string_list_item(item, &data->exclude_filters) {
217 if (subpath_matches(path, item->string) >= 0)
218 return 0;
219 }
220 }
221
222 if (data->ref_filters.nr) {
223 struct string_list_item *item;
224 int matched = 0;
225
226 /* See if any of the patterns match. */
227 for_each_string_list_item(item, &data->ref_filters) {
228 /*
229 * Check all patterns even after finding a match, so
230 * that we can see if a match with a subpath exists.
231 * When a user asked for 'refs/tags/v*' and 'v1.*',
232 * both of which match, the user is showing her
233 * willingness to accept a shortened output by having
234 * the 'v1.*' in the acceptable refnames, so we
235 * shouldn't stop when seeing 'refs/tags/v1.4' matches
236 * 'refs/tags/v*'. We should show it as 'v1.4'.
237 */
238 switch (subpath_matches(path, item->string)) {
239 case -1: /* did not match */
240 break;
241 case 0: /* matched fully */
242 matched = 1;
243 break;
244 default: /* matched subpath */
245 matched = 1;
246 can_abbreviate_output = 1;
247 break;
248 }
249 }
250
251 /* If none of the patterns matched, stop now */
252 if (!matched)
253 return 0;
254 }
255
256 add_to_tip_table(oid, path, can_abbreviate_output);
257
258 while (o && o->type == OBJ_TAG) {
259 struct tag *t = (struct tag *) o;
260 if (!t->tagged)
261 break; /* broken repository */
262 o = parse_object(the_repository, &t->tagged->oid);
263 deref = 1;
264 taggerdate = t->date;
265 }
266 if (o && o->type == OBJ_COMMIT) {
267 struct commit *commit = (struct commit *)o;
268 int from_tag = starts_with(path, "refs/tags/");
269
270 if (taggerdate == TIME_MAX)
271 taggerdate = ((struct commit *)o)->date;
272 path = name_ref_abbrev(path, can_abbreviate_output);
273 name_rev(commit, xstrdup(path), taggerdate, 0, 0,
274 from_tag, deref);
275 }
276 return 0;
277 }
278
279 static const unsigned char *nth_tip_table_ent(size_t ix, void *table_)
280 {
281 struct tip_table_entry *table = table_;
282 return table[ix].oid.hash;
283 }
284
285 static const char *get_exact_ref_match(const struct object *o)
286 {
287 int found;
288
289 if (!tip_table.table || !tip_table.nr)
290 return NULL;
291
292 if (!tip_table.sorted) {
293 QSORT(tip_table.table, tip_table.nr, tipcmp);
294 tip_table.sorted = 1;
295 }
296
297 found = sha1_pos(o->oid.hash, tip_table.table, tip_table.nr,
298 nth_tip_table_ent);
299 if (0 <= found)
300 return tip_table.table[found].refname;
301 return NULL;
302 }
303
304 /* may return a constant string or use "buf" as scratch space */
305 static const char *get_rev_name(const struct object *o, struct strbuf *buf)
306 {
307 struct rev_name *n;
308 struct commit *c;
309
310 if (o->type != OBJ_COMMIT)
311 return get_exact_ref_match(o);
312 c = (struct commit *) o;
313 n = get_commit_rev_name(c);
314 if (!n)
315 return NULL;
316
317 if (!n->generation)
318 return n->tip_name;
319 else {
320 int len = strlen(n->tip_name);
321 if (len > 2 && !strcmp(n->tip_name + len - 2, "^0"))
322 len -= 2;
323 strbuf_reset(buf);
324 strbuf_addf(buf, "%.*s~%d", len, n->tip_name, n->generation);
325 return buf->buf;
326 }
327 }
328
329 static void show_name(const struct object *obj,
330 const char *caller_name,
331 int always, int allow_undefined, int name_only)
332 {
333 const char *name;
334 const struct object_id *oid = &obj->oid;
335 struct strbuf buf = STRBUF_INIT;
336
337 if (!name_only)
338 printf("%s ", caller_name ? caller_name : oid_to_hex(oid));
339 name = get_rev_name(obj, &buf);
340 if (name)
341 printf("%s\n", name);
342 else if (allow_undefined)
343 printf("undefined\n");
344 else if (always)
345 printf("%s\n", find_unique_abbrev(oid, DEFAULT_ABBREV));
346 else
347 die("cannot describe '%s'", oid_to_hex(oid));
348 strbuf_release(&buf);
349 }
350
351 static char const * const name_rev_usage[] = {
352 N_("git name-rev [<options>] <commit>..."),
353 N_("git name-rev [<options>] --all"),
354 N_("git name-rev [<options>] --stdin"),
355 NULL
356 };
357
358 static void name_rev_line(char *p, struct name_ref_data *data)
359 {
360 struct strbuf buf = STRBUF_INIT;
361 int counter = 0;
362 char *p_start;
363 const unsigned hexsz = the_hash_algo->hexsz;
364
365 for (p_start = p; *p; p++) {
366 #define ishex(x) (isdigit((x)) || ((x) >= 'a' && (x) <= 'f'))
367 if (!ishex(*p))
368 counter = 0;
369 else if (++counter == hexsz &&
370 !ishex(*(p+1))) {
371 struct object_id oid;
372 const char *name = NULL;
373 char c = *(p+1);
374 int p_len = p - p_start + 1;
375
376 counter = 0;
377
378 *(p+1) = 0;
379 if (!get_oid(p - (hexsz - 1), &oid)) {
380 struct object *o =
381 lookup_object(the_repository,
382 oid.hash);
383 if (o)
384 name = get_rev_name(o, &buf);
385 }
386 *(p+1) = c;
387
388 if (!name)
389 continue;
390
391 if (data->name_only)
392 printf("%.*s%s", p_len - hexsz, p_start, name);
393 else
394 printf("%.*s (%s)", p_len, p_start, name);
395 p_start = p + 1;
396 }
397 }
398
399 /* flush */
400 if (p_start != p)
401 fwrite(p_start, p - p_start, 1, stdout);
402
403 strbuf_release(&buf);
404 }
405
406 int cmd_name_rev(int argc, const char **argv, const char *prefix)
407 {
408 struct object_array revs = OBJECT_ARRAY_INIT;
409 int all = 0, transform_stdin = 0, allow_undefined = 1, always = 0, peel_tag = 0;
410 struct name_ref_data data = { 0, 0, STRING_LIST_INIT_NODUP, STRING_LIST_INIT_NODUP };
411 struct option opts[] = {
412 OPT_BOOL(0, "name-only", &data.name_only, N_("print only names (no SHA-1)")),
413 OPT_BOOL(0, "tags", &data.tags_only, N_("only use tags to name the commits")),
414 OPT_STRING_LIST(0, "refs", &data.ref_filters, N_("pattern"),
415 N_("only use refs matching <pattern>")),
416 OPT_STRING_LIST(0, "exclude", &data.exclude_filters, N_("pattern"),
417 N_("ignore refs matching <pattern>")),
418 OPT_GROUP(""),
419 OPT_BOOL(0, "all", &all, N_("list all commits reachable from all refs")),
420 OPT_BOOL(0, "stdin", &transform_stdin, N_("read from stdin")),
421 OPT_BOOL(0, "undefined", &allow_undefined, N_("allow to print `undefined` names (default)")),
422 OPT_BOOL(0, "always", &always,
423 N_("show abbreviated commit object as fallback")),
424 {
425 /* A Hidden OPT_BOOL */
426 OPTION_SET_INT, 0, "peel-tag", &peel_tag, NULL,
427 N_("dereference tags in the input (internal use)"),
428 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, NULL, 1,
429 },
430 OPT_END(),
431 };
432
433 init_commit_rev_name(&rev_names);
434 git_config(git_default_config, NULL);
435 argc = parse_options(argc, argv, prefix, opts, name_rev_usage, 0);
436 if (all + transform_stdin + !!argc > 1) {
437 error("Specify either a list, or --all, not both!");
438 usage_with_options(name_rev_usage, opts);
439 }
440 if (all || transform_stdin)
441 cutoff = 0;
442
443 for (; argc; argc--, argv++) {
444 struct object_id oid;
445 struct object *object;
446 struct commit *commit;
447
448 if (get_oid(*argv, &oid)) {
449 fprintf(stderr, "Could not get sha1 for %s. Skipping.\n",
450 *argv);
451 continue;
452 }
453
454 commit = NULL;
455 object = parse_object(the_repository, &oid);
456 if (object) {
457 struct object *peeled = deref_tag(the_repository,
458 object, *argv, 0);
459 if (peeled && peeled->type == OBJ_COMMIT)
460 commit = (struct commit *)peeled;
461 }
462
463 if (!object) {
464 fprintf(stderr, "Could not get object for %s. Skipping.\n",
465 *argv);
466 continue;
467 }
468
469 if (commit) {
470 if (cutoff > commit->date)
471 cutoff = commit->date;
472 }
473
474 if (peel_tag) {
475 if (!commit) {
476 fprintf(stderr, "Could not get commit for %s. Skipping.\n",
477 *argv);
478 continue;
479 }
480 object = (struct object *)commit;
481 }
482 add_object_array(object, *argv, &revs);
483 }
484
485 if (cutoff)
486 cutoff = cutoff - CUTOFF_DATE_SLOP;
487 for_each_ref(name_ref, &data);
488
489 if (transform_stdin) {
490 char buffer[2048];
491
492 while (!feof(stdin)) {
493 char *p = fgets(buffer, sizeof(buffer), stdin);
494 if (!p)
495 break;
496 name_rev_line(p, &data);
497 }
498 } else if (all) {
499 int i, max;
500
501 max = get_max_object_index();
502 for (i = 0; i < max; i++) {
503 struct object *obj = get_indexed_object(i);
504 if (!obj || obj->type != OBJ_COMMIT)
505 continue;
506 show_name(obj, NULL,
507 always, allow_undefined, data.name_only);
508 }
509 } else {
510 int i;
511 for (i = 0; i < revs.nr; i++)
512 show_name(revs.objects[i].item, revs.objects[i].name,
513 always, allow_undefined, data.name_only);
514 }
515
516 UNLEAK(revs);
517 return 0;
518 }