Merge branch 'dt/log-follow-config' into maint
[git] / builtin / tag.c
1 /*
2  * Builtin "git tag"
3  *
4  * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>,
5  *                    Carlos Rica <jasampler@gmail.com>
6  * Based on git-tag.sh and mktag.c by Linus Torvalds.
7  */
8
9 #include "cache.h"
10 #include "builtin.h"
11 #include "refs.h"
12 #include "tag.h"
13 #include "run-command.h"
14 #include "parse-options.h"
15 #include "diff.h"
16 #include "revision.h"
17 #include "gpg-interface.h"
18 #include "sha1-array.h"
19 #include "column.h"
20
21 static const char * const git_tag_usage[] = {
22         N_("git tag [-a | -s | -u <key-id>] [-f] [-m <msg> | -F <file>] <tagname> [<head>]"),
23         N_("git tag -d <tagname>..."),
24         N_("git tag -l [-n[<num>]] [--contains <commit>] [--points-at <object>]"
25                 "\n\t\t[<pattern>...]"),
26         N_("git tag -v <tagname>..."),
27         NULL
28 };
29
30 #define STRCMP_SORT     0       /* must be zero */
31 #define VERCMP_SORT     1
32 #define SORT_MASK       0x7fff
33 #define REVERSE_SORT    0x8000
34
35 static int tag_sort;
36
37 struct tag_filter {
38         const char **patterns;
39         int lines;
40         int sort;
41         struct string_list tags;
42         struct commit_list *with_commit;
43 };
44
45 static struct sha1_array points_at;
46 static unsigned int colopts;
47
48 static int match_pattern(const char **patterns, const char *ref)
49 {
50         /* no pattern means match everything */
51         if (!*patterns)
52                 return 1;
53         for (; *patterns; patterns++)
54                 if (!wildmatch(*patterns, ref, 0, NULL))
55                         return 1;
56         return 0;
57 }
58
59 static const unsigned char *match_points_at(const char *refname,
60                                             const unsigned char *sha1)
61 {
62         const unsigned char *tagged_sha1 = NULL;
63         struct object *obj;
64
65         if (sha1_array_lookup(&points_at, sha1) >= 0)
66                 return sha1;
67         obj = parse_object(sha1);
68         if (!obj)
69                 die(_("malformed object at '%s'"), refname);
70         if (obj->type == OBJ_TAG)
71                 tagged_sha1 = ((struct tag *)obj)->tagged->sha1;
72         if (tagged_sha1 && sha1_array_lookup(&points_at, tagged_sha1) >= 0)
73                 return tagged_sha1;
74         return NULL;
75 }
76
77 static int in_commit_list(const struct commit_list *want, struct commit *c)
78 {
79         for (; want; want = want->next)
80                 if (!hashcmp(want->item->object.sha1, c->object.sha1))
81                         return 1;
82         return 0;
83 }
84
85 enum contains_result {
86         CONTAINS_UNKNOWN = -1,
87         CONTAINS_NO = 0,
88         CONTAINS_YES = 1
89 };
90
91 /*
92  * Test whether the candidate or one of its parents is contained in the list.
93  * Do not recurse to find out, though, but return -1 if inconclusive.
94  */
95 static enum contains_result contains_test(struct commit *candidate,
96                             const struct commit_list *want)
97 {
98         /* was it previously marked as containing a want commit? */
99         if (candidate->object.flags & TMP_MARK)
100                 return 1;
101         /* or marked as not possibly containing a want commit? */
102         if (candidate->object.flags & UNINTERESTING)
103                 return 0;
104         /* or are we it? */
105         if (in_commit_list(want, candidate)) {
106                 candidate->object.flags |= TMP_MARK;
107                 return 1;
108         }
109
110         if (parse_commit(candidate) < 0)
111                 return 0;
112
113         return -1;
114 }
115
116 /*
117  * Mimicking the real stack, this stack lives on the heap, avoiding stack
118  * overflows.
119  *
120  * At each recursion step, the stack items points to the commits whose
121  * ancestors are to be inspected.
122  */
123 struct stack {
124         int nr, alloc;
125         struct stack_entry {
126                 struct commit *commit;
127                 struct commit_list *parents;
128         } *stack;
129 };
130
131 static void push_to_stack(struct commit *candidate, struct stack *stack)
132 {
133         int index = stack->nr++;
134         ALLOC_GROW(stack->stack, stack->nr, stack->alloc);
135         stack->stack[index].commit = candidate;
136         stack->stack[index].parents = candidate->parents;
137 }
138
139 static enum contains_result contains(struct commit *candidate,
140                 const struct commit_list *want)
141 {
142         struct stack stack = { 0, 0, NULL };
143         int result = contains_test(candidate, want);
144
145         if (result != CONTAINS_UNKNOWN)
146                 return result;
147
148         push_to_stack(candidate, &stack);
149         while (stack.nr) {
150                 struct stack_entry *entry = &stack.stack[stack.nr - 1];
151                 struct commit *commit = entry->commit;
152                 struct commit_list *parents = entry->parents;
153
154                 if (!parents) {
155                         commit->object.flags |= UNINTERESTING;
156                         stack.nr--;
157                 }
158                 /*
159                  * If we just popped the stack, parents->item has been marked,
160                  * therefore contains_test will return a meaningful 0 or 1.
161                  */
162                 else switch (contains_test(parents->item, want)) {
163                 case CONTAINS_YES:
164                         commit->object.flags |= TMP_MARK;
165                         stack.nr--;
166                         break;
167                 case CONTAINS_NO:
168                         entry->parents = parents->next;
169                         break;
170                 case CONTAINS_UNKNOWN:
171                         push_to_stack(parents->item, &stack);
172                         break;
173                 }
174         }
175         free(stack.stack);
176         return contains_test(candidate, want);
177 }
178
179 static void show_tag_lines(const struct object_id *oid, int lines)
180 {
181         int i;
182         unsigned long size;
183         enum object_type type;
184         char *buf, *sp, *eol;
185         size_t len;
186
187         buf = read_sha1_file(oid->hash, &type, &size);
188         if (!buf)
189                 die_errno("unable to read object %s", oid_to_hex(oid));
190         if (type != OBJ_COMMIT && type != OBJ_TAG)
191                 goto free_return;
192         if (!size)
193                 die("an empty %s object %s?",
194                     typename(type), oid_to_hex(oid));
195
196         /* skip header */
197         sp = strstr(buf, "\n\n");
198         if (!sp)
199                 goto free_return;
200
201         /* only take up to "lines" lines, and strip the signature from a tag */
202         if (type == OBJ_TAG)
203                 size = parse_signature(buf, size);
204         for (i = 0, sp += 2; i < lines && sp < buf + size; i++) {
205                 if (i)
206                         printf("\n    ");
207                 eol = memchr(sp, '\n', size - (sp - buf));
208                 len = eol ? eol - sp : size - (sp - buf);
209                 fwrite(sp, len, 1, stdout);
210                 if (!eol)
211                         break;
212                 sp = eol + 1;
213         }
214 free_return:
215         free(buf);
216 }
217
218 static int show_reference(const char *refname, const struct object_id *oid,
219                           int flag, void *cb_data)
220 {
221         struct tag_filter *filter = cb_data;
222
223         if (match_pattern(filter->patterns, refname)) {
224                 if (filter->with_commit) {
225                         struct commit *commit;
226
227                         commit = lookup_commit_reference_gently(oid->hash, 1);
228                         if (!commit)
229                                 return 0;
230                         if (!contains(commit, filter->with_commit))
231                                 return 0;
232                 }
233
234                 if (points_at.nr && !match_points_at(refname, oid->hash))
235                         return 0;
236
237                 if (!filter->lines) {
238                         if (filter->sort)
239                                 string_list_append(&filter->tags, refname);
240                         else
241                                 printf("%s\n", refname);
242                         return 0;
243                 }
244                 printf("%-15s ", refname);
245                 show_tag_lines(oid, filter->lines);
246                 putchar('\n');
247         }
248
249         return 0;
250 }
251
252 static int sort_by_version(const void *a_, const void *b_)
253 {
254         const struct string_list_item *a = a_;
255         const struct string_list_item *b = b_;
256         return versioncmp(a->string, b->string);
257 }
258
259 static int list_tags(const char **patterns, int lines,
260                      struct commit_list *with_commit, int sort)
261 {
262         struct tag_filter filter;
263
264         filter.patterns = patterns;
265         filter.lines = lines;
266         filter.sort = sort;
267         filter.with_commit = with_commit;
268         memset(&filter.tags, 0, sizeof(filter.tags));
269         filter.tags.strdup_strings = 1;
270
271         for_each_tag_ref(show_reference, (void *)&filter);
272         if (sort) {
273                 int i;
274                 if ((sort & SORT_MASK) == VERCMP_SORT)
275                         qsort(filter.tags.items, filter.tags.nr,
276                               sizeof(struct string_list_item), sort_by_version);
277                 if (sort & REVERSE_SORT)
278                         for (i = filter.tags.nr - 1; i >= 0; i--)
279                                 printf("%s\n", filter.tags.items[i].string);
280                 else
281                         for (i = 0; i < filter.tags.nr; i++)
282                                 printf("%s\n", filter.tags.items[i].string);
283                 string_list_clear(&filter.tags, 0);
284         }
285         return 0;
286 }
287
288 typedef int (*each_tag_name_fn)(const char *name, const char *ref,
289                                 const unsigned char *sha1);
290
291 static int for_each_tag_name(const char **argv, each_tag_name_fn fn)
292 {
293         const char **p;
294         char ref[PATH_MAX];
295         int had_error = 0;
296         unsigned char sha1[20];
297
298         for (p = argv; *p; p++) {
299                 if (snprintf(ref, sizeof(ref), "refs/tags/%s", *p)
300                                         >= sizeof(ref)) {
301                         error(_("tag name too long: %.*s..."), 50, *p);
302                         had_error = 1;
303                         continue;
304                 }
305                 if (read_ref(ref, sha1)) {
306                         error(_("tag '%s' not found."), *p);
307                         had_error = 1;
308                         continue;
309                 }
310                 if (fn(*p, ref, sha1))
311                         had_error = 1;
312         }
313         return had_error;
314 }
315
316 static int delete_tag(const char *name, const char *ref,
317                                 const unsigned char *sha1)
318 {
319         if (delete_ref(ref, sha1, 0))
320                 return 1;
321         printf(_("Deleted tag '%s' (was %s)\n"), name, find_unique_abbrev(sha1, DEFAULT_ABBREV));
322         return 0;
323 }
324
325 static int verify_tag(const char *name, const char *ref,
326                                 const unsigned char *sha1)
327 {
328         const char *argv_verify_tag[] = {"verify-tag",
329                                         "-v", "SHA1_HEX", NULL};
330         argv_verify_tag[2] = sha1_to_hex(sha1);
331
332         if (run_command_v_opt(argv_verify_tag, RUN_GIT_CMD))
333                 return error(_("could not verify the tag '%s'"), name);
334         return 0;
335 }
336
337 static int do_sign(struct strbuf *buffer)
338 {
339         return sign_buffer(buffer, buffer, get_signing_key());
340 }
341
342 static const char tag_template[] =
343         N_("\nWrite a message for tag:\n  %s\n"
344         "Lines starting with '%c' will be ignored.\n");
345
346 static const char tag_template_nocleanup[] =
347         N_("\nWrite a message for tag:\n  %s\n"
348         "Lines starting with '%c' will be kept; you may remove them"
349         " yourself if you want to.\n");
350
351 /*
352  * Parse a sort string, and return 0 if parsed successfully. Will return
353  * non-zero when the sort string does not parse into a known type. If var is
354  * given, the error message becomes a warning and includes information about
355  * the configuration value.
356  */
357 static int parse_sort_string(const char *var, const char *arg, int *sort)
358 {
359         int type = 0, flags = 0;
360
361         if (skip_prefix(arg, "-", &arg))
362                 flags |= REVERSE_SORT;
363
364         if (skip_prefix(arg, "version:", &arg) || skip_prefix(arg, "v:", &arg))
365                 type = VERCMP_SORT;
366         else
367                 type = STRCMP_SORT;
368
369         if (strcmp(arg, "refname")) {
370                 if (!var)
371                         return error(_("unsupported sort specification '%s'"), arg);
372                 else {
373                         warning(_("unsupported sort specification '%s' in variable '%s'"),
374                                 var, arg);
375                         return -1;
376                 }
377         }
378
379         *sort = (type | flags);
380
381         return 0;
382 }
383
384 static int git_tag_config(const char *var, const char *value, void *cb)
385 {
386         int status;
387
388         if (!strcmp(var, "tag.sort")) {
389                 if (!value)
390                         return config_error_nonbool(var);
391                 parse_sort_string(var, value, &tag_sort);
392                 return 0;
393         }
394
395         status = git_gpg_config(var, value, cb);
396         if (status)
397                 return status;
398         if (starts_with(var, "column."))
399                 return git_column_config(var, value, "tag", &colopts);
400         return git_default_config(var, value, cb);
401 }
402
403 static void write_tag_body(int fd, const unsigned char *sha1)
404 {
405         unsigned long size;
406         enum object_type type;
407         char *buf, *sp;
408
409         buf = read_sha1_file(sha1, &type, &size);
410         if (!buf)
411                 return;
412         /* skip header */
413         sp = strstr(buf, "\n\n");
414
415         if (!sp || !size || type != OBJ_TAG) {
416                 free(buf);
417                 return;
418         }
419         sp += 2; /* skip the 2 LFs */
420         write_or_die(fd, sp, parse_signature(sp, buf + size - sp));
421
422         free(buf);
423 }
424
425 static int build_tag_object(struct strbuf *buf, int sign, unsigned char *result)
426 {
427         if (sign && do_sign(buf) < 0)
428                 return error(_("unable to sign the tag"));
429         if (write_sha1_file(buf->buf, buf->len, tag_type, result) < 0)
430                 return error(_("unable to write tag file"));
431         return 0;
432 }
433
434 struct create_tag_options {
435         unsigned int message_given:1;
436         unsigned int sign;
437         enum {
438                 CLEANUP_NONE,
439                 CLEANUP_SPACE,
440                 CLEANUP_ALL
441         } cleanup_mode;
442 };
443
444 static void create_tag(const unsigned char *object, const char *tag,
445                        struct strbuf *buf, struct create_tag_options *opt,
446                        unsigned char *prev, unsigned char *result)
447 {
448         enum object_type type;
449         char header_buf[1024];
450         int header_len;
451         char *path = NULL;
452
453         type = sha1_object_info(object, NULL);
454         if (type <= OBJ_NONE)
455             die(_("bad object type."));
456
457         header_len = snprintf(header_buf, sizeof(header_buf),
458                           "object %s\n"
459                           "type %s\n"
460                           "tag %s\n"
461                           "tagger %s\n\n",
462                           sha1_to_hex(object),
463                           typename(type),
464                           tag,
465                           git_committer_info(IDENT_STRICT));
466
467         if (header_len > sizeof(header_buf) - 1)
468                 die(_("tag header too big."));
469
470         if (!opt->message_given) {
471                 int fd;
472
473                 /* write the template message before editing: */
474                 path = git_pathdup("TAG_EDITMSG");
475                 fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);
476                 if (fd < 0)
477                         die_errno(_("could not create file '%s'"), path);
478
479                 if (!is_null_sha1(prev)) {
480                         write_tag_body(fd, prev);
481                 } else {
482                         struct strbuf buf = STRBUF_INIT;
483                         strbuf_addch(&buf, '\n');
484                         if (opt->cleanup_mode == CLEANUP_ALL)
485                                 strbuf_commented_addf(&buf, _(tag_template), tag, comment_line_char);
486                         else
487                                 strbuf_commented_addf(&buf, _(tag_template_nocleanup), tag, comment_line_char);
488                         write_or_die(fd, buf.buf, buf.len);
489                         strbuf_release(&buf);
490                 }
491                 close(fd);
492
493                 if (launch_editor(path, buf, NULL)) {
494                         fprintf(stderr,
495                         _("Please supply the message using either -m or -F option.\n"));
496                         exit(1);
497                 }
498         }
499
500         if (opt->cleanup_mode != CLEANUP_NONE)
501                 stripspace(buf, opt->cleanup_mode == CLEANUP_ALL);
502
503         if (!opt->message_given && !buf->len)
504                 die(_("no tag message?"));
505
506         strbuf_insert(buf, 0, header_buf, header_len);
507
508         if (build_tag_object(buf, opt->sign, result) < 0) {
509                 if (path)
510                         fprintf(stderr, _("The tag message has been left in %s\n"),
511                                 path);
512                 exit(128);
513         }
514         if (path) {
515                 unlink_or_warn(path);
516                 free(path);
517         }
518 }
519
520 struct msg_arg {
521         int given;
522         struct strbuf buf;
523 };
524
525 static int parse_msg_arg(const struct option *opt, const char *arg, int unset)
526 {
527         struct msg_arg *msg = opt->value;
528
529         if (!arg)
530                 return -1;
531         if (msg->buf.len)
532                 strbuf_addstr(&(msg->buf), "\n\n");
533         strbuf_addstr(&(msg->buf), arg);
534         msg->given = 1;
535         return 0;
536 }
537
538 static int strbuf_check_tag_ref(struct strbuf *sb, const char *name)
539 {
540         if (name[0] == '-')
541                 return -1;
542
543         strbuf_reset(sb);
544         strbuf_addf(sb, "refs/tags/%s", name);
545
546         return check_refname_format(sb->buf, 0);
547 }
548
549 static int parse_opt_points_at(const struct option *opt __attribute__((unused)),
550                         const char *arg, int unset)
551 {
552         unsigned char sha1[20];
553
554         if (unset) {
555                 sha1_array_clear(&points_at);
556                 return 0;
557         }
558         if (!arg)
559                 return error(_("switch 'points-at' requires an object"));
560         if (get_sha1(arg, sha1))
561                 return error(_("malformed object name '%s'"), arg);
562         sha1_array_append(&points_at, sha1);
563         return 0;
564 }
565
566 static int parse_opt_sort(const struct option *opt, const char *arg, int unset)
567 {
568         int *sort = opt->value;
569
570         return parse_sort_string(NULL, arg, sort);
571 }
572
573 int cmd_tag(int argc, const char **argv, const char *prefix)
574 {
575         struct strbuf buf = STRBUF_INIT;
576         struct strbuf ref = STRBUF_INIT;
577         unsigned char object[20], prev[20];
578         const char *object_ref, *tag;
579         struct create_tag_options opt;
580         char *cleanup_arg = NULL;
581         int annotate = 0, force = 0, lines = -1;
582         int create_reflog = 0;
583         int cmdmode = 0;
584         const char *msgfile = NULL, *keyid = NULL;
585         struct msg_arg msg = { 0, STRBUF_INIT };
586         struct commit_list *with_commit = NULL;
587         struct ref_transaction *transaction;
588         struct strbuf err = STRBUF_INIT;
589         struct option options[] = {
590                 OPT_CMDMODE('l', "list", &cmdmode, N_("list tag names"), 'l'),
591                 { OPTION_INTEGER, 'n', NULL, &lines, N_("n"),
592                                 N_("print <n> lines of each tag message"),
593                                 PARSE_OPT_OPTARG, NULL, 1 },
594                 OPT_CMDMODE('d', "delete", &cmdmode, N_("delete tags"), 'd'),
595                 OPT_CMDMODE('v', "verify", &cmdmode, N_("verify tags"), 'v'),
596
597                 OPT_GROUP(N_("Tag creation options")),
598                 OPT_BOOL('a', "annotate", &annotate,
599                                         N_("annotated tag, needs a message")),
600                 OPT_CALLBACK('m', "message", &msg, N_("message"),
601                              N_("tag message"), parse_msg_arg),
602                 OPT_FILENAME('F', "file", &msgfile, N_("read message from file")),
603                 OPT_BOOL('s', "sign", &opt.sign, N_("annotated and GPG-signed tag")),
604                 OPT_STRING(0, "cleanup", &cleanup_arg, N_("mode"),
605                         N_("how to strip spaces and #comments from message")),
606                 OPT_STRING('u', "local-user", &keyid, N_("key-id"),
607                                         N_("use another key to sign the tag")),
608                 OPT__FORCE(&force, N_("replace the tag if exists")),
609                 OPT_BOOL(0, "create-reflog", &create_reflog, N_("create a reflog")),
610
611                 OPT_GROUP(N_("Tag listing options")),
612                 OPT_COLUMN(0, "column", &colopts, N_("show tag list in columns")),
613                 {
614                         OPTION_CALLBACK, 0, "sort", &tag_sort, N_("type"), N_("sort tags"),
615                         PARSE_OPT_NONEG, parse_opt_sort
616                 },
617                 {
618                         OPTION_CALLBACK, 0, "contains", &with_commit, N_("commit"),
619                         N_("print only tags that contain the commit"),
620                         PARSE_OPT_LASTARG_DEFAULT,
621                         parse_opt_with_commit, (intptr_t)"HEAD",
622                 },
623                 {
624                         OPTION_CALLBACK, 0, "with", &with_commit, N_("commit"),
625                         N_("print only tags that contain the commit"),
626                         PARSE_OPT_HIDDEN | PARSE_OPT_LASTARG_DEFAULT,
627                         parse_opt_with_commit, (intptr_t)"HEAD",
628                 },
629                 {
630                         OPTION_CALLBACK, 0, "points-at", NULL, N_("object"),
631                         N_("print only tags of the object"), 0, parse_opt_points_at
632                 },
633                 OPT_END()
634         };
635
636         git_config(git_tag_config, NULL);
637
638         memset(&opt, 0, sizeof(opt));
639
640         argc = parse_options(argc, argv, prefix, options, git_tag_usage, 0);
641
642         if (keyid) {
643                 opt.sign = 1;
644                 set_signing_key(keyid);
645         }
646         if (opt.sign)
647                 annotate = 1;
648         if (argc == 0 && !cmdmode)
649                 cmdmode = 'l';
650
651         if ((annotate || msg.given || msgfile || force) && (cmdmode != 0))
652                 usage_with_options(git_tag_usage, options);
653
654         finalize_colopts(&colopts, -1);
655         if (cmdmode == 'l' && lines != -1) {
656                 if (explicitly_enable_column(colopts))
657                         die(_("--column and -n are incompatible"));
658                 colopts = 0;
659         }
660         if (cmdmode == 'l') {
661                 int ret;
662                 if (column_active(colopts)) {
663                         struct column_options copts;
664                         memset(&copts, 0, sizeof(copts));
665                         copts.padding = 2;
666                         run_column_filter(colopts, &copts);
667                 }
668                 if (lines != -1 && tag_sort)
669                         die(_("--sort and -n are incompatible"));
670                 ret = list_tags(argv, lines == -1 ? 0 : lines, with_commit, tag_sort);
671                 if (column_active(colopts))
672                         stop_column_filter();
673                 return ret;
674         }
675         if (lines != -1)
676                 die(_("-n option is only allowed with -l."));
677         if (with_commit)
678                 die(_("--contains option is only allowed with -l."));
679         if (points_at.nr)
680                 die(_("--points-at option is only allowed with -l."));
681         if (cmdmode == 'd')
682                 return for_each_tag_name(argv, delete_tag);
683         if (cmdmode == 'v')
684                 return for_each_tag_name(argv, verify_tag);
685
686         if (msg.given || msgfile) {
687                 if (msg.given && msgfile)
688                         die(_("only one -F or -m option is allowed."));
689                 annotate = 1;
690                 if (msg.given)
691                         strbuf_addbuf(&buf, &(msg.buf));
692                 else {
693                         if (!strcmp(msgfile, "-")) {
694                                 if (strbuf_read(&buf, 0, 1024) < 0)
695                                         die_errno(_("cannot read '%s'"), msgfile);
696                         } else {
697                                 if (strbuf_read_file(&buf, msgfile, 1024) < 0)
698                                         die_errno(_("could not open or read '%s'"),
699                                                 msgfile);
700                         }
701                 }
702         }
703
704         tag = argv[0];
705
706         object_ref = argc == 2 ? argv[1] : "HEAD";
707         if (argc > 2)
708                 die(_("too many params"));
709
710         if (get_sha1(object_ref, object))
711                 die(_("Failed to resolve '%s' as a valid ref."), object_ref);
712
713         if (strbuf_check_tag_ref(&ref, tag))
714                 die(_("'%s' is not a valid tag name."), tag);
715
716         if (read_ref(ref.buf, prev))
717                 hashclr(prev);
718         else if (!force)
719                 die(_("tag '%s' already exists"), tag);
720
721         opt.message_given = msg.given || msgfile;
722
723         if (!cleanup_arg || !strcmp(cleanup_arg, "strip"))
724                 opt.cleanup_mode = CLEANUP_ALL;
725         else if (!strcmp(cleanup_arg, "verbatim"))
726                 opt.cleanup_mode = CLEANUP_NONE;
727         else if (!strcmp(cleanup_arg, "whitespace"))
728                 opt.cleanup_mode = CLEANUP_SPACE;
729         else
730                 die(_("Invalid cleanup mode %s"), cleanup_arg);
731
732         if (annotate)
733                 create_tag(object, tag, &buf, &opt, prev, object);
734
735         transaction = ref_transaction_begin(&err);
736         if (!transaction ||
737             ref_transaction_update(transaction, ref.buf, object, prev,
738                                    create_reflog ? REF_FORCE_CREATE_REFLOG : 0,
739                                    NULL, &err) ||
740             ref_transaction_commit(transaction, &err))
741                 die("%s", err.buf);
742         ref_transaction_free(transaction);
743         if (force && !is_null_sha1(prev) && hashcmp(prev, object))
744                 printf(_("Updated tag '%s' (was %s)\n"), tag, find_unique_abbrev(prev, DEFAULT_ABBREV));
745
746         strbuf_release(&err);
747         strbuf_release(&buf);
748         strbuf_release(&ref);
749         return 0;
750 }