commit: add repository argument to lookup_commit_reference_gently
[git/git.git] / builtin / reflog.c
CommitLineData
4264dc15 1#include "builtin.h"
b2141fc1 2#include "config.h"
697cc8ef 3#include "lockfile.h"
cbd53a21 4#include "object-store.h"
109cd76d 5#include "repository.h"
4264dc15
JH
6#include "commit.h"
7#include "refs.h"
8#include "dir.h"
8d8b9f62 9#include "tree-walk.h"
1389d9dd
JH
10#include "diff.h"
11#include "revision.h"
12#include "reachable.h"
13
fe2a1816 14/* NEEDSWORK: switch to using parse_options */
1389d9dd 15static const char reflog_expire_usage[] =
fe2a1816 16"git reflog expire [--expire=<time>] [--expire-unreachable=<time>] [--rewrite] [--updateref] [--stale-fix] [--dry-run | -n] [--verbose] [--all] <refs>...";
3c386aa3 17static const char reflog_delete_usage[] =
fe2a1816 18"git reflog delete [--rewrite] [--updateref] [--dry-run | -n] [--verbose] <refs>...";
afcb2e7a
DT
19static const char reflog_exists_usage[] =
20"git reflog exists <ref>";
4264dc15 21
dddbad72
JS
22static timestamp_t default_reflog_expire;
23static timestamp_t default_reflog_expire_unreachable;
4aec56d1 24
1389d9dd
JH
25struct cmd_reflog_expire_cb {
26 struct rev_info revs;
1389d9dd 27 int stalefix;
dddbad72
JS
28 timestamp_t expire_total;
29 timestamp_t expire_unreachable;
552cecc2 30 int recno;
1389d9dd
JH
31};
32
ea7b4f6d 33struct expire_reflog_policy_cb {
03cb91b1
JH
34 enum {
35 UE_NORMAL,
36 UE_ALWAYS,
37 UE_HEAD
38 } unreachable_expire_kind;
b4ca1db9
JH
39 struct commit_list *mark_list;
40 unsigned long mark_limit;
b729effb 41 struct cmd_reflog_expire_cb cmd;
c48a1635
MH
42 struct commit *tip_commit;
43 struct commit_list *tips;
4264dc15
JH
44};
45
bda3a31c 46struct collected_reflog {
b8acac54 47 struct object_id oid;
bda3a31c
JH
48 char reflog[FLEX_ARRAY];
49};
ddd64c56 50
bda3a31c
JH
51struct collect_reflog_cb {
52 struct collected_reflog **e;
53 int alloc;
54 int nr;
55};
56
95308d64 57/* Remember to update object flag allocation in object.h */
cd1f9c36
JH
58#define INCOMPLETE (1u<<10)
59#define STUDYING (1u<<11)
494fbfe8 60#define REACHABLE (1u<<12)
cd1f9c36 61
49a09e74 62static int tree_is_complete(const struct object_id *oid)
8d8b9f62
JH
63{
64 struct tree_desc desc;
cd1f9c36
JH
65 struct name_entry entry;
66 int complete;
67 struct tree *tree;
8d8b9f62 68
f86bcc7b 69 tree = lookup_tree(the_repository, oid);
cd1f9c36 70 if (!tree)
8d8b9f62 71 return 0;
cd1f9c36
JH
72 if (tree->object.flags & SEEN)
73 return 1;
74 if (tree->object.flags & INCOMPLETE)
75 return 0;
76
6fda5e51 77 if (!tree->buffer) {
21666f1a 78 enum object_type type;
6fda5e51 79 unsigned long size;
b4f5aca4 80 void *data = read_object_file(oid, &type, &size);
cd1f9c36
JH
81 if (!data) {
82 tree->object.flags |= INCOMPLETE;
8d8b9f62
JH
83 return 0;
84 }
cd1f9c36 85 tree->buffer = data;
6fda5e51 86 tree->size = size;
8d8b9f62 87 }
6fda5e51 88 init_tree_desc(&desc, tree->buffer, tree->size);
cd1f9c36
JH
89 complete = 1;
90 while (tree_entry(&desc, &entry)) {
7d924c91 91 if (!has_sha1_file(entry.oid->hash) ||
49a09e74 92 (S_ISDIR(entry.mode) && !tree_is_complete(entry.oid))) {
cd1f9c36
JH
93 tree->object.flags |= INCOMPLETE;
94 complete = 0;
95 }
96 }
6e454b9a 97 free_tree_buffer(tree);
8d8b9f62 98
cd1f9c36
JH
99 if (complete)
100 tree->object.flags |= SEEN;
101 return complete;
102}
1389d9dd
JH
103
104static int commit_is_complete(struct commit *commit)
105{
106 struct object_array study;
107 struct object_array found;
108 int is_incomplete = 0;
109 int i;
110
111 /* early return */
112 if (commit->object.flags & SEEN)
113 return 1;
114 if (commit->object.flags & INCOMPLETE)
115 return 0;
116 /*
117 * Find all commits that are reachable and are not marked as
118 * SEEN. Then make sure the trees and blobs contained are
119 * complete. After that, mark these commits also as SEEN.
120 * If some of the objects that are needed to complete this
121 * commit are missing, mark this commit as INCOMPLETE.
122 */
123 memset(&study, 0, sizeof(study));
124 memset(&found, 0, sizeof(found));
125 add_object_array(&commit->object, NULL, &study);
126 add_object_array(&commit->object, NULL, &found);
127 commit->object.flags |= STUDYING;
128 while (study.nr) {
129 struct commit *c;
130 struct commit_list *parent;
131
71992039 132 c = (struct commit *)object_array_pop(&study);
109cd76d 133 if (!c->object.parsed && !parse_object(the_repository, &c->object.oid))
1389d9dd
JH
134 c->object.flags |= INCOMPLETE;
135
136 if (c->object.flags & INCOMPLETE) {
137 is_incomplete = 1;
138 break;
139 }
140 else if (c->object.flags & SEEN)
141 continue;
142 for (parent = c->parents; parent; parent = parent->next) {
143 struct commit *p = parent->item;
144 if (p->object.flags & STUDYING)
145 continue;
146 p->object.flags |= STUDYING;
147 add_object_array(&p->object, NULL, &study);
148 add_object_array(&p->object, NULL, &found);
149 }
150 }
151 if (!is_incomplete) {
cd1f9c36
JH
152 /*
153 * make sure all commits in "found" array have all the
1389d9dd
JH
154 * necessary objects.
155 */
cd1f9c36 156 for (i = 0; i < found.nr; i++) {
1389d9dd
JH
157 struct commit *c =
158 (struct commit *)found.objects[i].item;
2e27bd77 159 if (!tree_is_complete(get_commit_tree_oid(c))) {
1389d9dd 160 is_incomplete = 1;
cd1f9c36
JH
161 c->object.flags |= INCOMPLETE;
162 }
1389d9dd
JH
163 }
164 if (!is_incomplete) {
165 /* mark all found commits as complete, iow SEEN */
166 for (i = 0; i < found.nr; i++)
167 found.objects[i].item->flags |= SEEN;
168 }
169 }
170 /* clear flags from the objects we traversed */
171 for (i = 0; i < found.nr; i++)
172 found.objects[i].item->flags &= ~STUDYING;
173 if (is_incomplete)
174 commit->object.flags |= INCOMPLETE;
cd1f9c36
JH
175 else {
176 /*
177 * If we come here, we have (1) traversed the ancestry chain
178 * from the "commit" until we reach SEEN commits (which are
179 * known to be complete), and (2) made sure that the commits
180 * encountered during the above traversal refer to trees that
181 * are complete. Which means that we know *all* the commits
182 * we have seen during this process are complete.
183 */
184 for (i = 0; i < found.nr; i++)
185 found.objects[i].item->flags |= SEEN;
186 }
1389d9dd 187 /* free object arrays */
dcb572ab
188 object_array_clear(&study);
189 object_array_clear(&found);
1389d9dd
JH
190 return !is_incomplete;
191}
192
4322478a 193static int keep_entry(struct commit **it, struct object_id *oid)
4264dc15 194{
8d8b9f62
JH
195 struct commit *commit;
196
4322478a 197 if (is_null_oid(oid))
4264dc15 198 return 1;
21e1ee8f 199 commit = lookup_commit_reference_gently(the_repository, oid, 1);
8d8b9f62
JH
200 if (!commit)
201 return 0;
202
1389d9dd
JH
203 /*
204 * Make sure everything in this commit exists.
205 *
206 * We have walked all the objects reachable from the refs
207 * and cache earlier. The commits reachable by this commit
208 * must meet SEEN commits -- and then we should mark them as
209 * SEEN as well.
210 */
211 if (!commit_is_complete(commit))
8d8b9f62
JH
212 return 0;
213 *it = commit;
214 return 1;
4264dc15
JH
215}
216
b4ca1db9
JH
217/*
218 * Starting from commits in the cb->mark_list, mark commits that are
219 * reachable from them. Stop the traversal at commits older than
220 * the expire_limit and queue them back, so that the caller can call
221 * us again to restart the traversal with longer expire_limit.
222 */
ea7b4f6d 223static void mark_reachable(struct expire_reflog_policy_cb *cb)
666e07e6 224{
b4ca1db9 225 struct commit_list *pending;
dddbad72 226 timestamp_t expire_limit = cb->mark_limit;
b4ca1db9 227 struct commit_list *leftover = NULL;
666e07e6 228
b4ca1db9
JH
229 for (pending = cb->mark_list; pending; pending = pending->next)
230 pending->item->object.flags &= ~REACHABLE;
494fbfe8 231
b4ca1db9 232 pending = cb->mark_list;
494fbfe8 233 while (pending) {
494fbfe8 234 struct commit_list *parent;
e510ab89 235 struct commit *commit = pop_commit(&pending);
494fbfe8
JH
236 if (commit->object.flags & REACHABLE)
237 continue;
238 if (parse_commit(commit))
239 continue;
240 commit->object.flags |= REACHABLE;
b4ca1db9
JH
241 if (commit->date < expire_limit) {
242 commit_list_insert(commit, &leftover);
494fbfe8 243 continue;
b4ca1db9
JH
244 }
245 commit->object.flags |= REACHABLE;
494fbfe8
JH
246 parent = commit->parents;
247 while (parent) {
248 commit = parent->item;
249 parent = parent->next;
250 if (commit->object.flags & REACHABLE)
251 continue;
252 commit_list_insert(commit, &pending);
253 }
254 }
b4ca1db9
JH
255 cb->mark_list = leftover;
256}
257
4322478a 258static int unreachable(struct expire_reflog_policy_cb *cb, struct commit *commit, struct object_id *oid)
b4ca1db9
JH
259{
260 /*
261 * We may or may not have the commit yet - if not, look it
262 * up using the supplied sha1.
263 */
264 if (!commit) {
4322478a 265 if (is_null_oid(oid))
b4ca1db9
JH
266 return 0;
267
21e1ee8f
SB
268 commit = lookup_commit_reference_gently(the_repository, oid,
269 1);
b4ca1db9
JH
270
271 /* Not a commit -- keep it */
272 if (!commit)
273 return 0;
274 }
275
276 /* Reachable from the current ref? Don't prune. */
277 if (commit->object.flags & REACHABLE)
278 return 0;
279
280 if (cb->mark_list && cb->mark_limit) {
281 cb->mark_limit = 0; /* dig down to the root */
282 mark_reachable(cb);
283 }
284
285 return !(commit->object.flags & REACHABLE);
494fbfe8
JH
286}
287
60cc3c40
MH
288/*
289 * Return true iff the specified reflog entry should be expired.
290 */
4322478a 291static int should_expire_reflog_ent(struct object_id *ooid, struct object_id *noid,
dddbad72 292 const char *email, timestamp_t timestamp, int tz,
60cc3c40 293 const char *message, void *cb_data)
4264dc15 294{
ea7b4f6d 295 struct expire_reflog_policy_cb *cb = cb_data;
dfa5990d 296 struct commit *old_commit, *new_commit;
4264dc15 297
b729effb 298 if (timestamp < cb->cmd.expire_total)
60cc3c40 299 return 1;
2b81fab2 300
dfa5990d 301 old_commit = new_commit = NULL;
b729effb 302 if (cb->cmd.stalefix &&
dfa5990d 303 (!keep_entry(&old_commit, ooid) || !keep_entry(&new_commit, noid)))
60cc3c40 304 return 1;
4264dc15 305
b729effb 306 if (timestamp < cb->cmd.expire_unreachable) {
03cb91b1 307 if (cb->unreachable_expire_kind == UE_ALWAYS)
60cc3c40 308 return 1;
dfa5990d 309 if (unreachable(cb, old_commit, ooid) || unreachable(cb, new_commit, noid))
60cc3c40 310 return 1;
9bbaa6cc 311 }
4264dc15 312
b729effb 313 if (cb->cmd.recno && --(cb->cmd.recno) == 0)
60cc3c40
MH
314 return 1;
315
4264dc15 316 return 0;
60cc3c40
MH
317}
318
5bcad1bc 319static int push_tip_to_list(const char *refname, const struct object_id *oid,
ea7b4f6d 320 int flags, void *cb_data)
03cb91b1
JH
321{
322 struct commit_list **list = cb_data;
323 struct commit *tip_commit;
324 if (flags & REF_ISSYMREF)
325 return 0;
21e1ee8f 326 tip_commit = lookup_commit_reference_gently(the_repository, oid, 1);
03cb91b1
JH
327 if (!tip_commit)
328 return 0;
329 commit_list_insert(tip_commit, list);
330 return 0;
331}
332
c48a1635 333static void reflog_expiry_prepare(const char *refname,
4322478a 334 const struct object_id *oid,
b729effb 335 void *cb_data)
c48a1635 336{
b729effb
MH
337 struct expire_reflog_policy_cb *cb = cb_data;
338
339 if (!cb->cmd.expire_unreachable || !strcmp(refname, "HEAD")) {
c48a1635
MH
340 cb->tip_commit = NULL;
341 cb->unreachable_expire_kind = UE_HEAD;
342 } else {
21e1ee8f
SB
343 cb->tip_commit = lookup_commit_reference_gently(the_repository,
344 oid, 1);
c48a1635
MH
345 if (!cb->tip_commit)
346 cb->unreachable_expire_kind = UE_ALWAYS;
347 else
348 cb->unreachable_expire_kind = UE_NORMAL;
349 }
350
b729effb 351 if (cb->cmd.expire_unreachable <= cb->cmd.expire_total)
c48a1635
MH
352 cb->unreachable_expire_kind = UE_ALWAYS;
353
354 cb->mark_list = NULL;
355 cb->tips = NULL;
356 if (cb->unreachable_expire_kind != UE_ALWAYS) {
357 if (cb->unreachable_expire_kind == UE_HEAD) {
358 struct commit_list *elem;
2b2a5be3 359
5bcad1bc 360 for_each_ref(push_tip_to_list, &cb->tips);
c48a1635
MH
361 for (elem = cb->tips; elem; elem = elem->next)
362 commit_list_insert(elem->item, &cb->mark_list);
363 } else {
364 commit_list_insert(cb->tip_commit, &cb->mark_list);
365 }
b729effb 366 cb->mark_limit = cb->cmd.expire_total;
c48a1635
MH
367 mark_reachable(cb);
368 }
369}
370
b729effb 371static void reflog_expiry_cleanup(void *cb_data)
c48a1635 372{
b729effb
MH
373 struct expire_reflog_policy_cb *cb = cb_data;
374
c48a1635
MH
375 if (cb->unreachable_expire_kind != UE_ALWAYS) {
376 if (cb->unreachable_expire_kind == UE_HEAD) {
377 struct commit_list *elem;
378 for (elem = cb->tips; elem; elem = elem->next)
379 clear_commit_marks(elem->item, REACHABLE);
380 free_commit_list(cb->tips);
381 } else {
382 clear_commit_marks(cb->tip_commit, REACHABLE);
383 }
384 }
385}
386
5bcad1bc 387static int collect_reflog(const char *ref, const struct object_id *oid, int unused, void *cb_data)
bda3a31c
JH
388{
389 struct collected_reflog *e;
390 struct collect_reflog_cb *cb = cb_data;
bda3a31c 391
96ffc06f 392 FLEX_ALLOC_STR(e, reflog, ref);
b8acac54 393 oidcpy(&e->oid, oid);
bda3a31c
JH
394 ALLOC_GROW(cb->e, cb->nr + 1, cb->alloc);
395 cb->e[cb->nr++] = e;
396 return 0;
397}
398
3cb22b8e
JH
399static struct reflog_expire_cfg {
400 struct reflog_expire_cfg *next;
dddbad72
JS
401 timestamp_t expire_total;
402 timestamp_t expire_unreachable;
3cb22b8e
JH
403 char pattern[FLEX_ARRAY];
404} *reflog_expire_cfg, **reflog_expire_cfg_tail;
405
406static struct reflog_expire_cfg *find_cfg_ent(const char *pattern, size_t len)
4aec56d1 407{
3cb22b8e
JH
408 struct reflog_expire_cfg *ent;
409
410 if (!reflog_expire_cfg_tail)
411 reflog_expire_cfg_tail = &reflog_expire_cfg;
412
413 for (ent = reflog_expire_cfg; ent; ent = ent->next)
c3a700fb
JK
414 if (!strncmp(ent->pattern, pattern, len) &&
415 ent->pattern[len] == '\0')
3cb22b8e
JH
416 return ent;
417
96ffc06f 418 FLEX_ALLOC_MEM(ent, pattern, pattern, len);
3cb22b8e
JH
419 *reflog_expire_cfg_tail = ent;
420 reflog_expire_cfg_tail = &(ent->next);
421 return ent;
422}
423
3cb22b8e
JH
424/* expiry timer slot */
425#define EXPIRE_TOTAL 01
426#define EXPIRE_UNREACH 02
427
428static int reflog_expire_config(const char *var, const char *value, void *cb)
429{
b3873c33
JK
430 const char *pattern, *key;
431 int pattern_len;
dddbad72 432 timestamp_t expire;
3cb22b8e
JH
433 int slot;
434 struct reflog_expire_cfg *ent;
435
b3873c33 436 if (parse_config_key(var, "gc", &pattern, &pattern_len, &key) < 0)
3cb22b8e
JH
437 return git_default_config(var, value, cb);
438
b3873c33 439 if (!strcmp(key, "reflogexpire")) {
3cb22b8e 440 slot = EXPIRE_TOTAL;
5f967424 441 if (git_config_expiry_date(&expire, var, value))
3cb22b8e 442 return -1;
b3873c33 443 } else if (!strcmp(key, "reflogexpireunreachable")) {
3cb22b8e 444 slot = EXPIRE_UNREACH;
5f967424 445 if (git_config_expiry_date(&expire, var, value))
3cb22b8e
JH
446 return -1;
447 } else
448 return git_default_config(var, value, cb);
449
b3873c33 450 if (!pattern) {
3cb22b8e
JH
451 switch (slot) {
452 case EXPIRE_TOTAL:
453 default_reflog_expire = expire;
454 break;
455 case EXPIRE_UNREACH:
456 default_reflog_expire_unreachable = expire;
457 break;
458 }
4f342b96
JH
459 return 0;
460 }
3cb22b8e 461
b3873c33 462 ent = find_cfg_ent(pattern, pattern_len);
3cb22b8e
JH
463 if (!ent)
464 return -1;
465 switch (slot) {
466 case EXPIRE_TOTAL:
467 ent->expire_total = expire;
468 break;
469 case EXPIRE_UNREACH:
470 ent->expire_unreachable = expire;
471 break;
472 }
473 return 0;
474}
475
476static void set_reflog_expiry_param(struct cmd_reflog_expire_cb *cb, int slot, const char *ref)
477{
478 struct reflog_expire_cfg *ent;
479
480 if (slot == (EXPIRE_TOTAL|EXPIRE_UNREACH))
481 return; /* both given explicitly -- nothing to tweak */
482
483 for (ent = reflog_expire_cfg; ent; ent = ent->next) {
55d34269 484 if (!wildmatch(ent->pattern, ref, 0)) {
3cb22b8e
JH
485 if (!(slot & EXPIRE_TOTAL))
486 cb->expire_total = ent->expire_total;
487 if (!(slot & EXPIRE_UNREACH))
488 cb->expire_unreachable = ent->expire_unreachable;
489 return;
490 }
491 }
492
60bce2bb
JH
493 /*
494 * If unconfigured, make stash never expire
495 */
496 if (!strcmp(ref, "refs/stash")) {
497 if (!(slot & EXPIRE_TOTAL))
498 cb->expire_total = 0;
499 if (!(slot & EXPIRE_UNREACH))
500 cb->expire_unreachable = 0;
501 return;
502 }
503
3cb22b8e
JH
504 /* Nothing matched -- use the default value */
505 if (!(slot & EXPIRE_TOTAL))
506 cb->expire_total = default_reflog_expire;
507 if (!(slot & EXPIRE_UNREACH))
508 cb->expire_unreachable = default_reflog_expire_unreachable;
4aec56d1
JH
509}
510
4264dc15
JH
511static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)
512{
b729effb 513 struct expire_reflog_policy_cb cb;
dddbad72 514 timestamp_t now = time(NULL);
4264dc15 515 int i, status, do_all;
3cb22b8e 516 int explicit_expiry = 0;
aba56c89 517 unsigned int flags = 0;
4264dc15 518
4a9f4394
AS
519 default_reflog_expire_unreachable = now - 30 * 24 * 3600;
520 default_reflog_expire = now - 90 * 24 * 3600;
ef90d6d4 521 git_config(reflog_expire_config, NULL);
4aec56d1 522
4264dc15
JH
523 save_commit_buffer = 0;
524 do_all = status = 0;
525 memset(&cb, 0, sizeof(cb));
4aec56d1 526
b729effb
MH
527 cb.cmd.expire_total = default_reflog_expire;
528 cb.cmd.expire_unreachable = default_reflog_expire_unreachable;
4264dc15
JH
529
530 for (i = 1; i < argc; i++) {
531 const char *arg = argv[i];
532 if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
98f31d85 533 flags |= EXPIRE_REFLOGS_DRY_RUN;
59556548 534 else if (starts_with(arg, "--expire=")) {
b729effb 535 if (parse_expiry_date(arg + 9, &cb.cmd.expire_total))
3d27b9b0 536 die(_("'%s' is not a valid timestamp"), arg);
3cb22b8e
JH
537 explicit_expiry |= EXPIRE_TOTAL;
538 }
59556548 539 else if (starts_with(arg, "--expire-unreachable=")) {
b729effb 540 if (parse_expiry_date(arg + 21, &cb.cmd.expire_unreachable))
3d27b9b0 541 die(_("'%s' is not a valid timestamp"), arg);
3cb22b8e
JH
542 explicit_expiry |= EXPIRE_UNREACH;
543 }
1389d9dd 544 else if (!strcmp(arg, "--stale-fix"))
b729effb 545 cb.cmd.stalefix = 1;
2b81fab2 546 else if (!strcmp(arg, "--rewrite"))
553daf13 547 flags |= EXPIRE_REFLOGS_REWRITE;
55f10565 548 else if (!strcmp(arg, "--updateref"))
c4c4fbf8 549 flags |= EXPIRE_REFLOGS_UPDATE_REF;
4264dc15
JH
550 else if (!strcmp(arg, "--all"))
551 do_all = 1;
1389d9dd 552 else if (!strcmp(arg, "--verbose"))
bc11155c 553 flags |= EXPIRE_REFLOGS_VERBOSE;
4264dc15
JH
554 else if (!strcmp(arg, "--")) {
555 i++;
556 break;
557 }
558 else if (arg[0] == '-')
559 usage(reflog_expire_usage);
560 else
561 break;
562 }
3cb22b8e
JH
563
564 /*
565 * We can trust the commits and objects reachable from refs
566 * even in older repository. We cannot trust what's reachable
567 * from reflog if the repository was pruned with older git.
568 */
b729effb
MH
569 if (cb.cmd.stalefix) {
570 init_revisions(&cb.cmd.revs, prefix);
bc11155c 571 if (flags & EXPIRE_REFLOGS_VERBOSE)
1389d9dd 572 printf("Marking reachable objects...");
b729effb 573 mark_reachable_objects(&cb.cmd.revs, 0, 0, NULL);
bc11155c 574 if (flags & EXPIRE_REFLOGS_VERBOSE)
1389d9dd
JH
575 putchar('\n');
576 }
577
bda3a31c
JH
578 if (do_all) {
579 struct collect_reflog_cb collected;
580 int i;
581
582 memset(&collected, 0, sizeof(collected));
5bcad1bc 583 for_each_reflog(collect_reflog, &collected);
bda3a31c
JH
584 for (i = 0; i < collected.nr; i++) {
585 struct collected_reflog *e = collected.e[i];
b729effb 586 set_reflog_expiry_param(&cb.cmd, explicit_expiry, e->reflog);
0155f710 587 status |= reflog_expire(e->reflog, &e->oid, flags,
fa5b1830
MH
588 reflog_expiry_prepare,
589 should_expire_reflog_ent,
590 reflog_expiry_cleanup,
591 &cb);
bda3a31c
JH
592 free(e);
593 }
594 free(collected.e);
595 }
596
90fb46ec
PB
597 for (; i < argc; i++) {
598 char *ref;
b8acac54 599 struct object_id oid;
334dc52f 600 if (!dwim_log(argv[i], strlen(argv[i]), &oid, &ref)) {
90fb46ec 601 status |= error("%s points nowhere!", argv[i]);
4264dc15
JH
602 continue;
603 }
b729effb 604 set_reflog_expiry_param(&cb.cmd, explicit_expiry, ref);
0155f710 605 status |= reflog_expire(ref, &oid, flags,
fa5b1830
MH
606 reflog_expiry_prepare,
607 should_expire_reflog_ent,
608 reflog_expiry_cleanup,
609 &cb);
4264dc15
JH
610 }
611 return status;
612}
613
9461d272 614static int count_reflog_ent(struct object_id *ooid, struct object_id *noid,
dddbad72 615 const char *email, timestamp_t timestamp, int tz,
552cecc2
JS
616 const char *message, void *cb_data)
617{
b729effb
MH
618 struct expire_reflog_policy_cb *cb = cb_data;
619 if (!cb->cmd.expire_total || timestamp < cb->cmd.expire_total)
620 cb->cmd.recno++;
552cecc2
JS
621 return 0;
622}
623
624static int cmd_reflog_delete(int argc, const char **argv, const char *prefix)
625{
b729effb 626 struct expire_reflog_policy_cb cb;
552cecc2 627 int i, status = 0;
aba56c89 628 unsigned int flags = 0;
552cecc2 629
552cecc2
JS
630 memset(&cb, 0, sizeof(cb));
631
632 for (i = 1; i < argc; i++) {
3c386aa3
BC
633 const char *arg = argv[i];
634 if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
98f31d85 635 flags |= EXPIRE_REFLOGS_DRY_RUN;
2b81fab2 636 else if (!strcmp(arg, "--rewrite"))
553daf13 637 flags |= EXPIRE_REFLOGS_REWRITE;
55f10565 638 else if (!strcmp(arg, "--updateref"))
c4c4fbf8 639 flags |= EXPIRE_REFLOGS_UPDATE_REF;
3c386aa3 640 else if (!strcmp(arg, "--verbose"))
bc11155c 641 flags |= EXPIRE_REFLOGS_VERBOSE;
3c386aa3
BC
642 else if (!strcmp(arg, "--")) {
643 i++;
644 break;
645 }
646 else if (arg[0] == '-')
647 usage(reflog_delete_usage);
648 else
649 break;
650 }
651
652 if (argc - i < 1)
653 return error("Nothing to delete?");
654
655 for ( ; i < argc; i++) {
552cecc2 656 const char *spec = strstr(argv[i], "@{");
b8acac54 657 struct object_id oid;
552cecc2
JS
658 char *ep, *ref;
659 int recno;
660
661 if (!spec) {
cb97cc9f 662 status |= error("Not a reflog: %s", argv[i]);
552cecc2
JS
663 continue;
664 }
665
334dc52f 666 if (!dwim_log(argv[i], spec - argv[i], &oid, &ref)) {
55beff4f 667 status |= error("no reflog for '%s'", argv[i]);
552cecc2
JS
668 continue;
669 }
670
671 recno = strtoul(spec + 2, &ep, 10);
672 if (*ep == '}') {
b729effb 673 cb.cmd.recno = -recno;
552cecc2
JS
674 for_each_reflog_ent(ref, count_reflog_ent, &cb);
675 } else {
b729effb 676 cb.cmd.expire_total = approxidate(spec + 2);
552cecc2 677 for_each_reflog_ent(ref, count_reflog_ent, &cb);
b729effb 678 cb.cmd.expire_total = 0;
552cecc2
JS
679 }
680
0155f710 681 status |= reflog_expire(ref, &oid, flags,
fa5b1830
MH
682 reflog_expiry_prepare,
683 should_expire_reflog_ent,
684 reflog_expiry_cleanup,
685 &cb);
552cecc2
JS
686 free(ref);
687 }
688 return status;
689}
690
afcb2e7a
DT
691static int cmd_reflog_exists(int argc, const char **argv, const char *prefix)
692{
693 int i, start = 0;
694
695 for (i = 1; i < argc; i++) {
696 const char *arg = argv[i];
697 if (!strcmp(arg, "--")) {
698 i++;
699 break;
700 }
701 else if (arg[0] == '-')
702 usage(reflog_exists_usage);
703 else
704 break;
705 }
706
707 start = i;
708
709 if (argc - start != 1)
710 usage(reflog_exists_usage);
711
712 if (check_refname_format(argv[start], REFNAME_ALLOW_ONELEVEL))
713 die("invalid ref format: %s", argv[start]);
714 return !reflog_exists(argv[start]);
715}
716
1389d9dd
JH
717/*
718 * main "reflog"
719 */
720
4264dc15 721static const char reflog_usage[] =
afcb2e7a 722"git reflog [ show | expire | delete | exists ]";
4264dc15
JH
723
724int cmd_reflog(int argc, const char **argv, const char *prefix)
725{
99caeed0
JN
726 if (argc > 1 && !strcmp(argv[1], "-h"))
727 usage(reflog_usage);
728
cf39f54e
LT
729 /* With no command, we default to showing it. */
730 if (argc < 2 || *argv[1] == '-')
731 return cmd_log_reflog(argc, argv, prefix);
732
733 if (!strcmp(argv[1], "show"))
734 return cmd_log_reflog(argc - 1, argv + 1, prefix);
735
736 if (!strcmp(argv[1], "expire"))
4264dc15 737 return cmd_reflog_expire(argc - 1, argv + 1, prefix);
cf39f54e 738
552cecc2
JS
739 if (!strcmp(argv[1], "delete"))
740 return cmd_reflog_delete(argc - 1, argv + 1, prefix);
741
afcb2e7a
DT
742 if (!strcmp(argv[1], "exists"))
743 return cmd_reflog_exists(argc - 1, argv + 1, prefix);
744
bf01d4a3 745 return cmd_log_reflog(argc, argv, prefix);
4264dc15 746}