Merge branch 'ks/tag-cleanup'
authorJunio C Hamano <gitster@pobox.com>
Wed, 14 Dec 2011 07:03:00 +0000 (23:03 -0800)
committerJunio C Hamano <gitster@pobox.com>
Wed, 14 Dec 2011 07:07:47 +0000 (23:07 -0800)
* ks/tag-cleanup:
git-tag: introduce --cleanup option

Conflicts:
builtin/tag.c

1  2 
builtin/tag.c
diff --combined builtin/tag.c
index efb98726955837294190fcef365e45b0dd5f5396,0d68a95954e55cea1cf8de117d98ed3cd6970834..31f02e80f6b8fc22ed7ca7ae142c8d2f99084e8b
@@@ -14,7 -14,6 +14,7 @@@
  #include "parse-options.h"
  #include "diff.h"
  #include "revision.h"
 +#include "gpg-interface.h"
  
  static const char * const git_tag_usage[] = {
        "git tag [-a|-s|-u <key-id>] [-f] [-m <msg>|-F <file>] <tagname> [<head>]",
@@@ -24,6 -23,8 +24,6 @@@
        NULL
  };
  
 -static char signingkey[1000];
 -
  struct tag_filter {
        const char **patterns;
        int lines;
@@@ -173,7 -174,7 +173,7 @@@ static int for_each_tag_name(const cha
                        had_error = 1;
                        continue;
                }
 -              if (!resolve_ref(ref, sha1, 1, NULL)) {
 +              if (read_ref(ref, sha1)) {
                        error(_("tag '%s' not found."), *p);
                        had_error = 1;
                        continue;
@@@ -207,20 -208,92 +207,29 @@@ static int verify_tag(const char *name
  
  static int do_sign(struct strbuf *buffer)
  {
 -      struct child_process gpg;
 -      const char *args[4];
 -      char *bracket;
 -      int len;
 -      int i, j;
 -
 -      if (!*signingkey) {
 -              if (strlcpy(signingkey, git_committer_info(IDENT_ERROR_ON_NO_NAME),
 -                              sizeof(signingkey)) > sizeof(signingkey) - 1)
 -                      return error(_("committer info too long."));
 -              bracket = strchr(signingkey, '>');
 -              if (bracket)
 -                      bracket[1] = '\0';
 -      }
 -
 -      /* When the username signingkey is bad, program could be terminated
 -       * because gpg exits without reading and then write gets SIGPIPE. */
 -      signal(SIGPIPE, SIG_IGN);
 -
 -      memset(&gpg, 0, sizeof(gpg));
 -      gpg.argv = args;
 -      gpg.in = -1;
 -      gpg.out = -1;
 -      args[0] = "gpg";
 -      args[1] = "-bsau";
 -      args[2] = signingkey;
 -      args[3] = NULL;
 -
 -      if (start_command(&gpg))
 -              return error(_("could not run gpg."));
 -
 -      if (write_in_full(gpg.in, buffer->buf, buffer->len) != buffer->len) {
 -              close(gpg.in);
 -              close(gpg.out);
 -              finish_command(&gpg);
 -              return error(_("gpg did not accept the tag data"));
 -      }
 -      close(gpg.in);
 -      len = strbuf_read(buffer, gpg.out, 1024);
 -      close(gpg.out);
 -
 -      if (finish_command(&gpg) || !len || len < 0)
 -              return error(_("gpg failed to sign the tag"));
 -
 -      /* Strip CR from the line endings, in case we are on Windows. */
 -      for (i = j = 0; i < buffer->len; i++)
 -              if (buffer->buf[i] != '\r') {
 -                      if (i != j)
 -                              buffer->buf[j] = buffer->buf[i];
 -                      j++;
 -              }
 -      strbuf_setlen(buffer, j);
 -
 -      return 0;
 +      return sign_buffer(buffer, buffer, get_signing_key());
  }
  
  static const char tag_template[] =
        N_("\n"
        "#\n"
        "# Write a tag message\n"
+       "# Lines starting with '#' will be ignored.\n"
+       "#\n");
+ static const char tag_template_nocleanup[] =
+       N_("\n"
+       "#\n"
+       "# Write a tag message\n"
+       "# Lines starting with '#' will be kept; you may remove them"
+       " yourself if you want to.\n"
        "#\n");
  
 -static void set_signingkey(const char *value)
 -{
 -      if (strlcpy(signingkey, value, sizeof(signingkey)) >= sizeof(signingkey))
 -              die(_("signing key value too long (%.10s...)"), value);
 -}
 -
  static int git_tag_config(const char *var, const char *value, void *cb)
  {
 -      if (!strcmp(var, "user.signingkey")) {
 -              if (!value)
 -                      return config_error_nonbool(var);
 -              set_signingkey(value);
 -              return 0;
 -      }
 -
 +      int status = git_gpg_config(var, value, cb);
 +      if (status)
 +              return status;
        return git_default_config(var, value, cb);
  }
  
@@@ -255,8 -328,18 +264,18 @@@ static int build_tag_object(struct strb
        return 0;
  }
  
+ struct create_tag_options {
+       unsigned int message_given:1;
+       unsigned int sign;
+       enum {
+               CLEANUP_NONE,
+               CLEANUP_SPACE,
+               CLEANUP_ALL
+       } cleanup_mode;
+ };
  static void create_tag(const unsigned char *object, const char *tag,
-                      struct strbuf *buf, int message, int sign,
+                      struct strbuf *buf, struct create_tag_options *opt,
                       unsigned char *prev, unsigned char *result)
  {
        enum object_type type;
        if (header_len > sizeof(header_buf) - 1)
                die(_("tag header too big."));
  
-       if (!message) {
+       if (!opt->message_given) {
                int fd;
  
                /* write the template message before editing: */
  
                if (!is_null_sha1(prev))
                        write_tag_body(fd, prev);
+               else if (opt->cleanup_mode == CLEANUP_ALL)
+                       write_or_die(fd, _(tag_template),
+                                       strlen(_(tag_template)));
                else
-                       write_or_die(fd, _(tag_template), strlen(_(tag_template)));
+                       write_or_die(fd, _(tag_template_nocleanup),
+                                       strlen(_(tag_template_nocleanup)));
                close(fd);
  
                if (launch_editor(path, buf, NULL)) {
                }
        }
  
-       stripspace(buf, 1);
+       if (opt->cleanup_mode != CLEANUP_NONE)
+               stripspace(buf, opt->cleanup_mode == CLEANUP_ALL);
  
-       if (!message && !buf->len)
+       if (!opt->message_given && !buf->len)
                die(_("no tag message?"));
  
        strbuf_insert(buf, 0, header_buf, header_len);
  
-       if (build_tag_object(buf, sign, result) < 0) {
+       if (build_tag_object(buf, opt->sign, result) < 0) {
                if (path)
                        fprintf(stderr, _("The tag message has been left in %s\n"),
                                path);
@@@ -358,9 -446,10 +382,10 @@@ int cmd_tag(int argc, const char **argv
        unsigned char object[20], prev[20];
        const char *object_ref, *tag;
        struct ref_lock *lock;
-       int annotate = 0, sign = 0, force = 0, lines = -1,
-               list = 0, delete = 0, verify = 0;
+       struct create_tag_options opt;
+       char *cleanup_arg = NULL;
+       int annotate = 0, force = 0, lines = -1, list = 0,
+               delete = 0, verify = 0;
        const char *msgfile = NULL, *keyid = NULL;
        struct msg_arg msg = { 0, STRBUF_INIT };
        struct commit_list *with_commit = NULL;
                OPT_CALLBACK('m', "message", &msg, "message",
                             "tag message", parse_msg_arg),
                OPT_FILENAME('F', "file", &msgfile, "read message from file"),
-               OPT_BOOLEAN('s', "sign", &sign, "annotated and GPG-signed tag"),
+               OPT_BOOLEAN('s', "sign", &opt.sign, "annotated and GPG-signed tag"),
+               OPT_STRING(0, "cleanup", &cleanup_arg, "mode",
+                       "how to strip spaces and #comments from message"),
                OPT_STRING('u', "local-user", &keyid, "key-id",
                                        "use another key to sign the tag"),
                OPT__FORCE(&force, "replace the tag if exists"),
  
        git_config(git_tag_config, NULL);
  
+       memset(&opt, 0, sizeof(opt));
        argc = parse_options(argc, argv, prefix, options, git_tag_usage, 0);
  
        if (keyid) {
-               sign = 1;
+               opt.sign = 1;
 -              set_signingkey(keyid);
 +              set_signing_key(keyid);
        }
-       if (sign)
+       if (opt.sign)
                annotate = 1;
        if (argc == 0 && !(delete || verify))
                list = 1;
        if (strbuf_check_tag_ref(&ref, tag))
                die(_("'%s' is not a valid tag name."), tag);
  
 -      if (!resolve_ref(ref.buf, prev, 1, NULL))
 +      if (read_ref(ref.buf, prev))
                hashclr(prev);
        else if (!force)
                die(_("tag '%s' already exists"), tag);
  
+       opt.message_given = msg.given || msgfile;
+       if (!cleanup_arg || !strcmp(cleanup_arg, "strip"))
+               opt.cleanup_mode = CLEANUP_ALL;
+       else if (!strcmp(cleanup_arg, "verbatim"))
+               opt.cleanup_mode = CLEANUP_NONE;
+       else if (!strcmp(cleanup_arg, "whitespace"))
+               opt.cleanup_mode = CLEANUP_SPACE;
+       else
+               die(_("Invalid cleanup mode %s"), cleanup_arg);
        if (annotate)
-               create_tag(object, tag, &buf, msg.given || msgfile,
-                          sign, prev, object);
+               create_tag(object, tag, &buf, &opt, prev, object);
  
        lock = lock_any_ref_for_update(ref.buf, prev, 0);
        if (!lock)