builtin-am: support and auto-detect StGit patches

Since c574e68 (git-am foreign patch support: StGIT support, 2009-05-27),
git-am.sh supported converting StGit patches into RFC2822 mail patches
that can be parsed with git-mailinfo.

Implement this by introducing two functions in builtin/am.c:
stgit_patch_to_mail() and split_mail_conv().

stgit_patch_to_mail() is a callback function for split_mail_conv(), and
contains the logic for converting an StGit patch into an RFC2822 mail
patch.

split_mail_conv() implements the logic to go through each file in the
`paths` list, reading from stdin where specified, and calls the callback
function to write the converted patch to the corresponding output file
in the state directory. This interface should be generic enough to
support other foreign patch formats in the future.

Since 15ced75 (git-am foreign patch support: autodetect some patch
formats, 2009-05-27), git-am.sh is able to auto-detect StGit patches.
Re-implement this in builtin/am.c.

Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Paul Tan <pyokagan@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/am.c b/builtin/am.c
index 33d1f24d07bf12a350dc1e0c4eba952ba226400a..d82d07edaab317faa751c2b4c36f91d66d9622b9 100644 (file)
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -65,9 +65,22 @@ static int linelen(const char *msg)
        return strchrnul(msg, '\n') - msg;
 }
 
        return strchrnul(msg, '\n') - msg;
 }
 

+/**
+ * Returns true if `str` consists of only whitespace, false otherwise.
+ */
+static int str_isspace(const char *str)
+{
+       for (; *str; str++)
+               if (!isspace(*str))
+                       return 0;
+
+       return 1;
+}
+

 enum patch_format {
        PATCH_FORMAT_UNKNOWN = 0,
 enum patch_format {
        PATCH_FORMAT_UNKNOWN = 0,

-       PATCH_FORMAT_MBOX
+       PATCH_FORMAT_MBOX,
+       PATCH_FORMAT_STGIT

 };
 
 enum keep_type {
 };
 
 enum keep_type {


@@ -610,6 +623,8 @@ static int detect_patch_format(const char **paths)
 {
        enum patch_format ret = PATCH_FORMAT_UNKNOWN;
        struct strbuf l1 = STRBUF_INIT;
 {
        enum patch_format ret = PATCH_FORMAT_UNKNOWN;
        struct strbuf l1 = STRBUF_INIT;

+       struct strbuf l2 = STRBUF_INIT;
+       struct strbuf l3 = STRBUF_INIT;

        FILE *fp;
 
        /*
        FILE *fp;
 
        /*


@@ -635,6 +650,23 @@ static int detect_patch_format(const char **paths)
                goto done;
        }
 
                goto done;
        }
 

+       strbuf_reset(&l2);
+       strbuf_getline_crlf(&l2, fp);
+       strbuf_reset(&l3);
+       strbuf_getline_crlf(&l3, fp);
+
+       /*
+        * If the second line is empty and the third is a From, Author or Date
+        * entry, this is likely an StGit patch.
+        */
+       if (l1.len && !l2.len &&
+               (starts_with(l3.buf, "From:") ||
+                starts_with(l3.buf, "Author:") ||
+                starts_with(l3.buf, "Date:"))) {
+               ret = PATCH_FORMAT_STGIT;
+               goto done;
+       }
+

        if (l1.len && is_mail(fp)) {
                ret = PATCH_FORMAT_MBOX;
                goto done;
        if (l1.len && is_mail(fp)) {
                ret = PATCH_FORMAT_MBOX;
                goto done;


@@ -674,6 +706,100 @@ static int split_mail_mbox(struct am_state *state, const char **paths, int keep_
        return 0;
 }
 
        return 0;
 }
 

+/**
+ * Callback signature for split_mail_conv(). The foreign patch should be
+ * read from `in`, and the converted patch (in RFC2822 mail format) should be
+ * written to `out`. Return 0 on success, or -1 on failure.
+ */
+typedef int (*mail_conv_fn)(FILE *out, FILE *in, int keep_cr);
+
+/**
+ * Calls `fn` for each file in `paths` to convert the foreign patch to the
+ * RFC2822 mail format suitable for parsing with git-mailinfo.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int split_mail_conv(mail_conv_fn fn, struct am_state *state,
+                       const char **paths, int keep_cr)
+{
+       static const char *stdin_only[] = {"-", NULL};
+       int i;
+
+       if (!*paths)
+               paths = stdin_only;
+
+       for (i = 0; *paths; paths++, i++) {
+               FILE *in, *out;
+               const char *mail;
+               int ret;
+
+               if (!strcmp(*paths, "-"))
+                       in = stdin;
+               else
+                       in = fopen(*paths, "r");
+
+               if (!in)
+                       return error(_("could not open '%s' for reading: %s"),
+                                       *paths, strerror(errno));
+
+               mail = mkpath("%s/%0*d", state->dir, state->prec, i + 1);
+
+               out = fopen(mail, "w");
+               if (!out)
+                       return error(_("could not open '%s' for writing: %s"),
+                                       mail, strerror(errno));
+
+               ret = fn(out, in, keep_cr);
+
+               fclose(out);
+               fclose(in);
+
+               if (ret)
+                       return error(_("could not parse patch '%s'"), *paths);
+       }
+
+       state->cur = 1;
+       state->last = i;
+       return 0;
+}
+
+/**
+ * A split_mail_conv() callback that converts an StGit patch to an RFC2822
+ * message suitable for parsing with git-mailinfo.
+ */
+static int stgit_patch_to_mail(FILE *out, FILE *in, int keep_cr)
+{
+       struct strbuf sb = STRBUF_INIT;
+       int subject_printed = 0;
+
+       while (!strbuf_getline(&sb, in, '\n')) {
+               const char *str;
+
+               if (str_isspace(sb.buf))
+                       continue;
+               else if (skip_prefix(sb.buf, "Author:", &str))
+                       fprintf(out, "From:%s\n", str);
+               else if (starts_with(sb.buf, "From") || starts_with(sb.buf, "Date"))
+                       fprintf(out, "%s\n", sb.buf);
+               else if (!subject_printed) {
+                       fprintf(out, "Subject: %s\n", sb.buf);
+                       subject_printed = 1;
+               } else {
+                       fprintf(out, "\n%s\n", sb.buf);
+                       break;
+               }
+       }
+
+       strbuf_reset(&sb);
+       while (strbuf_fread(&sb, 8192, in) > 0) {
+               fwrite(sb.buf, 1, sb.len, out);
+               strbuf_reset(&sb);
+       }
+
+       strbuf_release(&sb);
+       return 0;
+}
+

 /**
  * Splits a list of files/directories into individual email patches. Each path
  * in `paths` must be a file/directory that is formatted according to
 /**
  * Splits a list of files/directories into individual email patches. Each path
  * in `paths` must be a file/directory that is formatted according to


@@ -702,6 +828,8 @@ static int split_mail(struct am_state *state, enum patch_format patch_format,
        switch (patch_format) {
        case PATCH_FORMAT_MBOX:
                return split_mail_mbox(state, paths, keep_cr);
        switch (patch_format) {
        case PATCH_FORMAT_MBOX:
                return split_mail_mbox(state, paths, keep_cr);

+       case PATCH_FORMAT_STGIT:
+               return split_mail_conv(stgit_patch_to_mail, state, paths, keep_cr);

        default:
                die("BUG: invalid patch_format");
        }
        default:
                die("BUG: invalid patch_format");
        }


@@ -1750,6 +1878,8 @@ static int parse_opt_patchformat(const struct option *opt, const char *arg, int
 
        if (!strcmp(arg, "mbox"))
                *opt_value = PATCH_FORMAT_MBOX;
 
        if (!strcmp(arg, "mbox"))
                *opt_value = PATCH_FORMAT_MBOX;

+       else if (!strcmp(arg, "stgit"))
+               *opt_value = PATCH_FORMAT_STGIT;

        else
                return error(_("Invalid value for --patch-format: %s"), arg);
        return 0;
        else
                return error(_("Invalid value for --patch-format: %s"), arg);
        return 0;