From: Paul Tan <pyokagan@gmail.com>
To: git@vger.kernel.org
Cc: Johannes Schindelin <johannes.schindelin@gmx.de>,
Stefan Beller <sbeller@google.com>, Paul Tan <pyokagan@gmail.com>
Subject: [PATCH/WIP v3 07/31] am: extract patch, message and authorship with git-mailinfo
Date: Thu, 18 Jun 2015 19:25:19 +0800 [thread overview]
Message-ID: <1434626743-8552-8-git-send-email-pyokagan@gmail.com> (raw)
In-Reply-To: <1434626743-8552-1-git-send-email-pyokagan@gmail.com>
For the purpose of applying the patch and committing the results,
implement extracting the patch data, commit message and authorship from
an e-mail message using git-mailinfo.
git-mailinfo is run as a separate process, but ideally in the future,
we should be be able to access its functionality directly without
spawning a new process.
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Jeff King <peff@peff.net>
Signed-off-by: Paul Tan <pyokagan@gmail.com>
---
Notes:
v3
* Style fixes
builtin/am.c | 232 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 232 insertions(+)
diff --git a/builtin/am.c b/builtin/am.c
index 7b97ea8..d6434e4 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -9,6 +9,23 @@
#include "parse-options.h"
#include "dir.h"
#include "run-command.h"
+#include "quote.h"
+
+/**
+ * Returns 1 if the file is empty or does not exist, 0 otherwise.
+ */
+static int is_empty_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
enum patch_format {
PATCH_FORMAT_UNKNOWN = 0,
@@ -23,6 +40,12 @@ struct am_state {
int cur;
int last;
+ /* commit message and metadata */
+ struct strbuf author_name;
+ struct strbuf author_email;
+ struct strbuf author_date;
+ struct strbuf msg;
+
/* number of digits in patch filename */
int prec;
};
@@ -36,6 +59,11 @@ static void am_state_init(struct am_state *state)
strbuf_init(&state->dir, 0);
+ strbuf_init(&state->author_name, 0);
+ strbuf_init(&state->author_email, 0);
+ strbuf_init(&state->author_date, 0);
+ strbuf_init(&state->msg, 0);
+
state->prec = 4;
}
@@ -45,6 +73,10 @@ static void am_state_init(struct am_state *state)
static void am_state_release(struct am_state *state)
{
strbuf_release(&state->dir);
+ strbuf_release(&state->author_name);
+ strbuf_release(&state->author_email);
+ strbuf_release(&state->author_date);
+ strbuf_release(&state->msg);
}
/**
@@ -94,6 +126,105 @@ static int read_state_file(struct strbuf *sb, const char *file, size_t hint, int
}
/**
+ * Reads a KEY=VALUE shell variable assignment from fp, and returns the VALUE
+ * in `value`. VALUE must be a quoted string, and the KEY must match `key`.
+ * Returns 0 on success, -1 on failure.
+ *
+ * This is used by read_author_script() to read the GIT_AUTHOR_* variables from
+ * the author-script.
+ */
+static int read_shell_var(struct strbuf *value, FILE *fp, const char *key)
+{
+ struct strbuf sb = STRBUF_INIT;
+ char *str;
+
+ if (strbuf_getline(&sb, fp, '\n'))
+ return -1;
+
+ if (!skip_prefix(sb.buf, key, (const char **)&str))
+ return -1;
+
+ if (!skip_prefix(str, "=", (const char **)&str))
+ return -1;
+
+ str = sq_dequote(str);
+ if (!str)
+ return -1;
+
+ strbuf_reset(value);
+ strbuf_addstr(value, str);
+
+ strbuf_release(&sb);
+
+ return 0;
+}
+
+/**
+ * Parses the "author script" `filename`, and sets state->author_name,
+ * state->author_email and state->author_date accordingly. We are strict with
+ * our parsing, as the author script is supposed to be eval'd, and loosely
+ * parsing it may not give the results the user expects.
+ *
+ * The author script is of the format:
+ *
+ * GIT_AUTHOR_NAME='$author_name'
+ * GIT_AUTHOR_EMAIL='$author_email'
+ * GIT_AUTHOR_DATE='$author_date'
+ *
+ * where $author_name, $author_email and $author_date are quoted.
+ */
+static int read_author_script(struct am_state *state)
+{
+ const char *filename = am_path(state, "author-script");
+ FILE *fp = fopen(filename, "r");
+ if (!fp) {
+ if (errno == ENOENT)
+ return 0;
+ die_errno(_("could not open '%s' for reading"), filename);
+ }
+
+ if (read_shell_var(&state->author_name, fp, "GIT_AUTHOR_NAME"))
+ return -1;
+
+ if (read_shell_var(&state->author_email, fp, "GIT_AUTHOR_EMAIL"))
+ return -1;
+
+ if (read_shell_var(&state->author_date, fp, "GIT_AUTHOR_DATE"))
+ return -1;
+
+ if (fgetc(fp) != EOF)
+ return -1;
+
+ fclose(fp);
+ return 0;
+}
+
+/**
+ * Saves state->author_name, state->author_email and state->author_date in
+ * `filename` as an "author script", which is the format used by git-am.sh.
+ */
+static void write_author_script(const struct am_state *state)
+{
+ static const char fmt[] = "GIT_AUTHOR_NAME=%s\n"
+ "GIT_AUTHOR_EMAIL=%s\n"
+ "GIT_AUTHOR_DATE=%s\n";
+ struct strbuf author_name = STRBUF_INIT;
+ struct strbuf author_email = STRBUF_INIT;
+ struct strbuf author_date = STRBUF_INIT;
+
+ sq_quote_buf(&author_name, state->author_name.buf);
+ sq_quote_buf(&author_email, state->author_email.buf);
+ sq_quote_buf(&author_date, state->author_date.buf);
+
+ write_file(am_path(state, "author-script"), 1, fmt,
+ author_name.buf, author_email.buf, author_date.buf);
+
+ strbuf_release(&author_name);
+ strbuf_release(&author_email);
+ strbuf_release(&author_date);
+}
+
+/**
* Loads state from disk.
*/
static void am_load(struct am_state *state)
@@ -106,6 +237,11 @@ static void am_load(struct am_state *state)
read_state_file(&sb, am_path(state, "last"), 8, 1);
state->last = strtol(sb.buf, NULL, 10);
+ if (read_author_script(state) < 0)
+ die(_("could not parse author script"));
+
+ read_state_file(&state->msg, am_path(state, "final-commit"), 0, 0);
+
strbuf_release(&sb);
}
@@ -296,6 +432,91 @@ static void am_next(struct am_state *state)
{
state->cur++;
write_file(am_path(state, "next"), 1, "%d", state->cur);
+
+ strbuf_reset(&state->author_name);
+ strbuf_reset(&state->author_email);
+ strbuf_reset(&state->author_date);
+ unlink(am_path(state, "author-script"));
+
+ strbuf_reset(&state->msg);
+ unlink(am_path(state, "final-commit"));
+}
+
+/**
+ * Returns the filename of the current patch.
+ */
+static const char *msgnum(const struct am_state *state)
+{
+ static struct strbuf sb = STRBUF_INIT;
+
+ strbuf_reset(&sb);
+ strbuf_addf(&sb, "%0*d", state->prec, state->cur);
+
+ return sb.buf;
+}
+
+/**
+ * Parses `patch` using git-mailinfo. state->msg will be set to the patch
+ * message. state->author_name, state->author_email, state->author_date will be
+ * set to the patch author's name, email and date respectively. The patch's
+ * body will be written to "$state_dir/patch", where $state_dir is the state
+ * directory.
+ *
+ * Returns 1 if the patch should be skipped, 0 otherwise.
+ */
+static int parse_patch(struct am_state *state, const char *patch)
+{
+ FILE *fp;
+ struct child_process cp = CHILD_PROCESS_INIT;
+ struct strbuf sb = STRBUF_INIT;
+
+ cp.git_cmd = 1;
+ cp.in = xopen(patch, O_RDONLY, 0);
+ cp.out = xopen(am_path(state, "info"), O_WRONLY | O_CREAT, 0777);
+
+ argv_array_push(&cp.args, "mailinfo");
+ argv_array_push(&cp.args, am_path(state, "msg"));
+ argv_array_push(&cp.args, am_path(state, "patch"));
+
+ if (run_command(&cp) < 0)
+ die("could not parse patch");
+
+ close(cp.in);
+ close(cp.out);
+
+ /* Extract message and author information */
+ fp = xfopen(am_path(state, "info"), "r");
+ while (!strbuf_getline(&sb, fp, '\n')) {
+ const char *x;
+
+ if (skip_prefix(sb.buf, "Subject: ", &x)) {
+ if (state->msg.len)
+ strbuf_addch(&state->msg, '\n');
+ strbuf_addstr(&state->msg, x);
+ } else if (skip_prefix(sb.buf, "Author: ", &x))
+ strbuf_addstr(&state->author_name, x);
+ else if (skip_prefix(sb.buf, "Email: ", &x))
+ strbuf_addstr(&state->author_email, x);
+ else if (skip_prefix(sb.buf, "Date: ", &x))
+ strbuf_addstr(&state->author_date, x);
+ }
+ fclose(fp);
+
+ /* Skip pine's internal folder data */
+ if (!strcmp(state->author_name.buf, "Mail System Internal Data"))
+ return 1;
+
+ if (is_empty_file(am_path(state, "patch")))
+ die(_("Patch is empty. Was it split wrong?\n"
+ "If you would prefer to skip this patch, instead run \"git am --skip\".\n"
+ "To restore the original branch and stop patching run \"git am --abort\"."));
+
+ strbuf_addstr(&state->msg, "\n\n");
+ if (strbuf_read_file(&state->msg, am_path(state, "msg"), 0) < 0)
+ die_errno(_("could not read '%s'"), am_path(state, "msg"));
+ stripspace(&state->msg, 0);
+
+ return 0;
}
/**
@@ -304,9 +525,20 @@ static void am_next(struct am_state *state)
static void am_run(struct am_state *state)
{
while (state->cur <= state->last) {
+ const char *patch = am_path(state, msgnum(state));
+
+ if (!file_exists(patch))
+ goto next;
+
+ if (parse_patch(state, patch))
+ goto next; /* patch should be skipped */
+
+ write_author_script(state);
+ write_file(am_path(state, "final-commit"), 1, "%s", state->msg.buf);
/* TODO: Patch application not implemented yet */
+next:
am_next(state);
}
--
2.1.4
next prev parent reply other threads:[~2015-06-18 11:26 UTC|newest]
Thread overview: 64+ messages / expand[flat|nested] mbox.gz Atom feed top
2015-06-18 11:25 [PATCH/WIP v3 00/31] Make git-am a builtin Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 01/31] wrapper: implement xopen() Paul Tan
2015-06-24 16:28 ` Johannes Schindelin
2015-06-24 16:59 ` Stefan Beller
2015-06-24 18:39 ` Johannes Schindelin
2015-07-01 9:41 ` Paul Tan
2015-07-01 9:53 ` Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 02/31] wrapper: implement xfopen() Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 03/31] am: implement skeletal builtin am Paul Tan
2015-06-18 20:26 ` Junio C Hamano
2015-06-19 9:56 ` Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 04/31] am: implement patch queue mechanism Paul Tan
2015-06-18 17:47 ` Stefan Beller
2015-06-18 20:43 ` Junio C Hamano
2015-06-19 12:49 ` Paul Tan
2015-06-24 14:59 ` Johannes Schindelin
2015-06-25 15:16 ` Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 05/31] am: split out mbox/maildir patches with git-mailsplit Paul Tan
2015-06-18 20:52 ` Junio C Hamano
2015-06-18 11:25 ` [PATCH/WIP v3 06/31] am: detect mbox patches Paul Tan
2015-06-18 21:02 ` Junio C Hamano
2015-06-24 8:41 ` Paul Tan
2015-06-24 15:10 ` Johannes Schindelin
2015-06-25 13:40 ` Paul Tan
2015-06-26 7:42 ` Paul Tan
2015-06-18 11:25 ` Paul Tan [this message]
2015-06-18 21:10 ` [PATCH/WIP v3 07/31] am: extract patch, message and authorship with git-mailinfo Junio C Hamano
2015-06-19 9:22 ` Paul Tan
2015-06-19 16:13 ` Junio C Hamano
2015-06-24 7:54 ` Paul Tan
2015-06-24 15:59 ` Junio C Hamano
2015-06-25 11:54 ` Paul Tan
[not found] ` <CAPc5daVbpB_T4cY1xvLrBKPUZw0JNMXqNAOsKE-R7NPO2nrnZA@mail.gmail.com>
2015-06-19 16:15 ` Paul Tan
2015-06-19 20:12 ` Johannes Schindelin
2015-06-24 16:36 ` Johannes Schindelin
2015-06-26 8:11 ` Paul Tan
2015-06-26 20:41 ` Junio C Hamano
2015-06-18 11:25 ` [PATCH/WIP v3 08/31] am: apply patch with git-apply Paul Tan
2015-06-18 21:23 ` Junio C Hamano
2015-06-18 11:25 ` [PATCH/WIP v3 09/31] am: commit applied patch Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 10/31] am: refresh the index at start Paul Tan
2015-06-18 21:28 ` Junio C Hamano
2015-06-19 8:07 ` Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 11/31] am: refuse to apply patches if index is dirty Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 12/31] am: implement --resolved/--continue Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 13/31] am: implement --skip Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 14/31] am: implement --abort Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 15/31] am: don't accept patches when there's a session in progress Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 16/31] am: implement quiet option Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 17/31] am: exit with user friendly message on patch failure Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 18/31] am: implement am --signoff Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 19/31] cache-tree: introduce write_index_as_tree() Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 20/31] am: implement 3-way merge Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 21/31] am: --rebasing Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 22/31] am: don't use git-mailinfo if --rebasing Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 23/31] am: handle stray state directory Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 24/31] am: implement -k/--keep, --keep-non-patch Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 25/31] am: implement --[no-]message-id, am.messageid Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 26/31] am: support --keep-cr, am.keepcr Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 27/31] am: implement --[no-]scissors Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 28/31] am: pass git-apply's options to git-apply Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 29/31] am: implement --ignore-date Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 30/31] am: implement --committer-date-is-author-date Paul Tan
2015-06-18 11:25 ` [PATCH/WIP v3 31/31] am: implement -S/--gpg-sign, commit.gpgsign Paul Tan
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1434626743-8552-8-git-send-email-pyokagan@gmail.com \
--to=pyokagan@gmail.com \
--cc=git@vger.kernel.org \
--cc=johannes.schindelin@gmx.de \
--cc=sbeller@google.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.