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.
14 #include "run-command.h"
15 #include "parse-options.h"
18 #include "gpg-interface.h"
19 #include "sha1-array.h"
21 #include "ref-filter.h"
23 static const char * const git_tag_usage
[] = {
24 N_("git tag [-a | -s | -u <key-id>] [-f] [-m <msg> | -F <file>] <tagname> [<head>]"),
25 N_("git tag -d <tagname>..."),
26 N_("git tag -l [-n[<num>]] [--contains <commit>] [--no-contains <commit>] [--points-at <object>]"
27 "\n\t\t[--format=<format>] [--[no-]merged [<commit>]] [<pattern>...]"),
28 N_("git tag -v [--format=<format>] <tagname>..."),
32 static unsigned int colopts
;
33 static int force_sign_annotate
;
35 static int list_tags(struct ref_filter
*filter
, struct ref_sorting
*sorting
, const char *format
)
37 struct ref_array array
;
41 memset(&array
, 0, sizeof(array
));
43 if (filter
->lines
== -1)
48 to_free
= xstrfmt("%s %%(contents:lines=%d)",
49 "%(align:15)%(refname:lstrip=2)%(end)",
53 format
= "%(refname:lstrip=2)";
56 if (verify_ref_format(format
))
57 die(_("unable to parse format string"));
58 filter
->with_commit_tag_algo
= 1;
59 filter_refs(&array
, filter
, FILTER_REFS_TAGS
);
60 ref_array_sort(sorting
, &array
);
62 for (i
= 0; i
< array
.nr
; i
++)
63 show_ref_array_item(array
.items
[i
], format
, 0);
64 ref_array_clear(&array
);
70 typedef int (*each_tag_name_fn
)(const char *name
, const char *ref
,
71 const struct object_id
*oid
, const void *cb_data
);
73 static int for_each_tag_name(const char **argv
, each_tag_name_fn fn
,
77 struct strbuf ref
= STRBUF_INIT
;
81 for (p
= argv
; *p
; p
++) {
83 strbuf_addf(&ref
, "refs/tags/%s", *p
);
84 if (read_ref(ref
.buf
, oid
.hash
)) {
85 error(_("tag '%s' not found."), *p
);
89 if (fn(*p
, ref
.buf
, &oid
, cb_data
))
96 static int delete_tag(const char *name
, const char *ref
,
97 const struct object_id
*oid
, const void *cb_data
)
99 if (delete_ref(NULL
, ref
, oid
->hash
, 0))
101 printf(_("Deleted tag '%s' (was %s)\n"), name
, find_unique_abbrev(oid
->hash
, DEFAULT_ABBREV
));
105 static int verify_tag(const char *name
, const char *ref
,
106 const struct object_id
*oid
, const void *cb_data
)
109 const char *fmt_pretty
= cb_data
;
110 flags
= GPG_VERIFY_VERBOSE
;
113 flags
= GPG_VERIFY_OMIT_STATUS
;
115 if (gpg_verify_tag(oid
->hash
, name
, flags
))
119 pretty_print_ref(name
, oid
->hash
, fmt_pretty
);
124 static int do_sign(struct strbuf
*buffer
)
126 return sign_buffer(buffer
, buffer
, get_signing_key());
129 static const char tag_template
[] =
130 N_("\nWrite a message for tag:\n %s\n"
131 "Lines starting with '%c' will be ignored.\n");
133 static const char tag_template_nocleanup
[] =
134 N_("\nWrite a message for tag:\n %s\n"
135 "Lines starting with '%c' will be kept; you may remove them"
136 " yourself if you want to.\n");
138 /* Parse arg given and add it the ref_sorting array */
139 static int parse_sorting_string(const char *arg
, struct ref_sorting
**sorting_tail
)
141 struct ref_sorting
*s
;
144 s
= xcalloc(1, sizeof(*s
));
145 s
->next
= *sorting_tail
;
152 if (skip_prefix(arg
, "version:", &arg
) ||
153 skip_prefix(arg
, "v:", &arg
))
157 s
->atom
= parse_ref_filter_atom(arg
, arg
+len
);
162 static int git_tag_config(const char *var
, const char *value
, void *cb
)
165 struct ref_sorting
**sorting_tail
= (struct ref_sorting
**)cb
;
167 if (!strcmp(var
, "tag.sort")) {
169 return config_error_nonbool(var
);
170 parse_sorting_string(value
, sorting_tail
);
174 status
= git_gpg_config(var
, value
, cb
);
177 if (!strcmp(var
, "tag.forcesignannotated")) {
178 force_sign_annotate
= git_config_bool(var
, value
);
182 if (starts_with(var
, "column."))
183 return git_column_config(var
, value
, "tag", &colopts
);
184 return git_default_config(var
, value
, cb
);
187 static void write_tag_body(int fd
, const struct object_id
*oid
)
190 enum object_type type
;
193 buf
= read_sha1_file(oid
->hash
, &type
, &size
);
197 sp
= strstr(buf
, "\n\n");
199 if (!sp
|| !size
|| type
!= OBJ_TAG
) {
203 sp
+= 2; /* skip the 2 LFs */
204 write_or_die(fd
, sp
, parse_signature(sp
, buf
+ size
- sp
));
209 static int build_tag_object(struct strbuf
*buf
, int sign
, struct object_id
*result
)
211 if (sign
&& do_sign(buf
) < 0)
212 return error(_("unable to sign the tag"));
213 if (write_sha1_file(buf
->buf
, buf
->len
, tag_type
, result
->hash
) < 0)
214 return error(_("unable to write tag file"));
218 struct create_tag_options
{
219 unsigned int message_given
:1;
228 static void create_tag(const struct object_id
*object
, const char *tag
,
229 struct strbuf
*buf
, struct create_tag_options
*opt
,
230 struct object_id
*prev
, struct object_id
*result
)
232 enum object_type type
;
233 struct strbuf header
= STRBUF_INIT
;
236 type
= sha1_object_info(object
->hash
, NULL
);
237 if (type
<= OBJ_NONE
)
238 die(_("bad object type."));
248 git_committer_info(IDENT_STRICT
));
250 if (!opt
->message_given
) {
253 /* write the template message before editing: */
254 path
= git_pathdup("TAG_EDITMSG");
255 fd
= open(path
, O_CREAT
| O_TRUNC
| O_WRONLY
, 0600);
257 die_errno(_("could not create file '%s'"), path
);
259 if (!is_null_oid(prev
)) {
260 write_tag_body(fd
, prev
);
262 struct strbuf buf
= STRBUF_INIT
;
263 strbuf_addch(&buf
, '\n');
264 if (opt
->cleanup_mode
== CLEANUP_ALL
)
265 strbuf_commented_addf(&buf
, _(tag_template
), tag
, comment_line_char
);
267 strbuf_commented_addf(&buf
, _(tag_template_nocleanup
), tag
, comment_line_char
);
268 write_or_die(fd
, buf
.buf
, buf
.len
);
269 strbuf_release(&buf
);
273 if (launch_editor(path
, buf
, NULL
)) {
275 _("Please supply the message using either -m or -F option.\n"));
280 if (opt
->cleanup_mode
!= CLEANUP_NONE
)
281 strbuf_stripspace(buf
, opt
->cleanup_mode
== CLEANUP_ALL
);
283 if (!opt
->message_given
&& !buf
->len
)
284 die(_("no tag message?"));
286 strbuf_insert(buf
, 0, header
.buf
, header
.len
);
287 strbuf_release(&header
);
289 if (build_tag_object(buf
, opt
->sign
, result
) < 0) {
291 fprintf(stderr
, _("The tag message has been left in %s\n"),
296 unlink_or_warn(path
);
301 static void create_reflog_msg(const struct object_id
*oid
, struct strbuf
*sb
)
303 enum object_type type
;
308 const char *subject_start
;
310 char *rla
= getenv("GIT_REFLOG_ACTION");
312 strbuf_addstr(sb
, rla
);
314 strbuf_addstr(sb
, "tag: tagging ");
315 strbuf_add_unique_abbrev(sb
, oid
->hash
, DEFAULT_ABBREV
);
318 strbuf_addstr(sb
, " (");
319 type
= sha1_object_info(oid
->hash
, NULL
);
322 strbuf_addstr(sb
, "object of unknown type");
325 if ((buf
= read_sha1_file(oid
->hash
, &type
, &size
)) != NULL
) {
326 subject_len
= find_commit_subject(buf
, &subject_start
);
327 strbuf_insert(sb
, sb
->len
, subject_start
, subject_len
);
329 strbuf_addstr(sb
, "commit object");
333 if ((c
= lookup_commit_reference(oid
)) != NULL
)
334 strbuf_addf(sb
, ", %s", show_date(c
->date
, 0, DATE_MODE(SHORT
)));
337 strbuf_addstr(sb
, "tree object");
340 strbuf_addstr(sb
, "blob object");
343 strbuf_addstr(sb
, "other tag object");
346 strbuf_addch(sb
, ')');
354 static int parse_msg_arg(const struct option
*opt
, const char *arg
, int unset
)
356 struct msg_arg
*msg
= opt
->value
;
361 strbuf_addstr(&(msg
->buf
), "\n\n");
362 strbuf_addstr(&(msg
->buf
), arg
);
367 static int strbuf_check_tag_ref(struct strbuf
*sb
, const char *name
)
373 strbuf_addf(sb
, "refs/tags/%s", name
);
375 return check_refname_format(sb
->buf
, 0);
378 int cmd_tag(int argc
, const char **argv
, const char *prefix
)
380 struct strbuf buf
= STRBUF_INIT
;
381 struct strbuf ref
= STRBUF_INIT
;
382 struct strbuf reflog_msg
= STRBUF_INIT
;
383 struct object_id object
, prev
;
384 const char *object_ref
, *tag
;
385 struct create_tag_options opt
;
386 char *cleanup_arg
= NULL
;
387 int create_reflog
= 0;
388 int annotate
= 0, force
= 0;
389 int cmdmode
= 0, create_tag_object
= 0;
390 const char *msgfile
= NULL
, *keyid
= NULL
;
391 struct msg_arg msg
= { 0, STRBUF_INIT
};
392 struct ref_transaction
*transaction
;
393 struct strbuf err
= STRBUF_INIT
;
394 struct ref_filter filter
;
395 static struct ref_sorting
*sorting
= NULL
, **sorting_tail
= &sorting
;
396 const char *format
= NULL
;
398 struct option options
[] = {
399 OPT_CMDMODE('l', "list", &cmdmode
, N_("list tag names"), 'l'),
400 { OPTION_INTEGER
, 'n', NULL
, &filter
.lines
, N_("n"),
401 N_("print <n> lines of each tag message"),
402 PARSE_OPT_OPTARG
, NULL
, 1 },
403 OPT_CMDMODE('d', "delete", &cmdmode
, N_("delete tags"), 'd'),
404 OPT_CMDMODE('v', "verify", &cmdmode
, N_("verify tags"), 'v'),
406 OPT_GROUP(N_("Tag creation options")),
407 OPT_BOOL('a', "annotate", &annotate
,
408 N_("annotated tag, needs a message")),
409 OPT_CALLBACK('m', "message", &msg
, N_("message"),
410 N_("tag message"), parse_msg_arg
),
411 OPT_FILENAME('F', "file", &msgfile
, N_("read message from file")),
412 OPT_BOOL('s', "sign", &opt
.sign
, N_("annotated and GPG-signed tag")),
413 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("mode"),
414 N_("how to strip spaces and #comments from message")),
415 OPT_STRING('u', "local-user", &keyid
, N_("key-id"),
416 N_("use another key to sign the tag")),
417 OPT__FORCE(&force
, N_("replace the tag if exists")),
418 OPT_BOOL(0, "create-reflog", &create_reflog
, N_("create a reflog")),
420 OPT_GROUP(N_("Tag listing options")),
421 OPT_COLUMN(0, "column", &colopts
, N_("show tag list in columns")),
422 OPT_CONTAINS(&filter
.with_commit
, N_("print only tags that contain the commit")),
423 OPT_NO_CONTAINS(&filter
.no_commit
, N_("print only tags that don't contain the commit")),
424 OPT_WITH(&filter
.with_commit
, N_("print only tags that contain the commit")),
425 OPT_WITHOUT(&filter
.no_commit
, N_("print only tags that don't contain the commit")),
426 OPT_MERGED(&filter
, N_("print only tags that are merged")),
427 OPT_NO_MERGED(&filter
, N_("print only tags that are not merged")),
428 OPT_CALLBACK(0 , "sort", sorting_tail
, N_("key"),
429 N_("field name to sort on"), &parse_opt_ref_sorting
),
431 OPTION_CALLBACK
, 0, "points-at", &filter
.points_at
, N_("object"),
432 N_("print only tags of the object"), PARSE_OPT_LASTARG_DEFAULT
,
433 parse_opt_object_name
, (intptr_t) "HEAD"
435 OPT_STRING( 0 , "format", &format
, N_("format"), N_("format to use for the output")),
436 OPT_BOOL('i', "ignore-case", &icase
, N_("sorting and filtering are case insensitive")),
440 setup_ref_filter_porcelain_msg();
442 git_config(git_tag_config
, sorting_tail
);
444 memset(&opt
, 0, sizeof(opt
));
445 memset(&filter
, 0, sizeof(filter
));
448 argc
= parse_options(argc
, argv
, prefix
, options
, git_tag_usage
, 0);
452 set_signing_key(keyid
);
454 create_tag_object
= (opt
.sign
|| annotate
|| msg
.given
|| msgfile
);
459 else if (filter
.with_commit
|| filter
.no_commit
||
460 filter
.points_at
.nr
|| filter
.merge_commit
||
465 if ((create_tag_object
|| force
) && (cmdmode
!= 0))
466 usage_with_options(git_tag_usage
, options
);
468 finalize_colopts(&colopts
, -1);
469 if (cmdmode
== 'l' && filter
.lines
!= -1) {
470 if (explicitly_enable_column(colopts
))
471 die(_("--column and -n are incompatible"));
475 sorting
= ref_default_sorting();
476 sorting
->ignore_case
= icase
;
477 filter
.ignore_case
= icase
;
478 if (cmdmode
== 'l') {
480 if (column_active(colopts
)) {
481 struct column_options copts
;
482 memset(&copts
, 0, sizeof(copts
));
484 run_column_filter(colopts
, &copts
);
486 filter
.name_patterns
= argv
;
487 ret
= list_tags(&filter
, sorting
, format
);
488 if (column_active(colopts
))
489 stop_column_filter();
492 if (filter
.lines
!= -1)
493 die(_("-n option is only allowed in list mode"));
494 if (filter
.with_commit
)
495 die(_("--contains option is only allowed in list mode"));
496 if (filter
.no_commit
)
497 die(_("--no-contains option is only allowed in list mode"));
498 if (filter
.points_at
.nr
)
499 die(_("--points-at option is only allowed in list mode"));
500 if (filter
.merge_commit
)
501 die(_("--merged and --no-merged options are only allowed in list mode"));
503 return for_each_tag_name(argv
, delete_tag
, NULL
);
504 if (cmdmode
== 'v') {
505 if (format
&& verify_ref_format(format
))
506 usage_with_options(git_tag_usage
, options
);
507 return for_each_tag_name(argv
, verify_tag
, format
);
510 if (msg
.given
|| msgfile
) {
511 if (msg
.given
&& msgfile
)
512 die(_("only one -F or -m option is allowed."));
514 strbuf_addbuf(&buf
, &(msg
.buf
));
516 if (!strcmp(msgfile
, "-")) {
517 if (strbuf_read(&buf
, 0, 1024) < 0)
518 die_errno(_("cannot read '%s'"), msgfile
);
520 if (strbuf_read_file(&buf
, msgfile
, 1024) < 0)
521 die_errno(_("could not open or read '%s'"),
529 object_ref
= argc
== 2 ? argv
[1] : "HEAD";
531 die(_("too many params"));
533 if (get_oid(object_ref
, &object
))
534 die(_("Failed to resolve '%s' as a valid ref."), object_ref
);
536 if (strbuf_check_tag_ref(&ref
, tag
))
537 die(_("'%s' is not a valid tag name."), tag
);
539 if (read_ref(ref
.buf
, prev
.hash
))
542 die(_("tag '%s' already exists"), tag
);
544 opt
.message_given
= msg
.given
|| msgfile
;
546 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "strip"))
547 opt
.cleanup_mode
= CLEANUP_ALL
;
548 else if (!strcmp(cleanup_arg
, "verbatim"))
549 opt
.cleanup_mode
= CLEANUP_NONE
;
550 else if (!strcmp(cleanup_arg
, "whitespace"))
551 opt
.cleanup_mode
= CLEANUP_SPACE
;
553 die(_("Invalid cleanup mode %s"), cleanup_arg
);
555 create_reflog_msg(&object
, &reflog_msg
);
557 if (create_tag_object
) {
558 if (force_sign_annotate
&& !annotate
)
560 create_tag(&object
, tag
, &buf
, &opt
, &prev
, &object
);
563 transaction
= ref_transaction_begin(&err
);
565 ref_transaction_update(transaction
, ref
.buf
, object
.hash
, prev
.hash
,
566 create_reflog
? REF_FORCE_CREATE_REFLOG
: 0,
567 reflog_msg
.buf
, &err
) ||
568 ref_transaction_commit(transaction
, &err
))
570 ref_transaction_free(transaction
);
571 if (force
&& !is_null_oid(&prev
) && oidcmp(&prev
, &object
))
572 printf(_("Updated tag '%s' (was %s)\n"), tag
, find_unique_abbrev(prev
.hash
, DEFAULT_ABBREV
));
574 strbuf_release(&err
);
575 strbuf_release(&buf
);
576 strbuf_release(&ref
);
577 strbuf_release(&reflog_msg
);