[PATCH 1/2] notmuch-reply: Add support for replying only to sender

[PATCH 1/2] notmuch-reply: Add support for replying only to sender

[Aneesh Kumar K.V]

From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>

This patch add --format=sender-only option.

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
---
 notmuch-reply.c |   76 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 76 insertions(+), 0 deletions(-)

diff --git a/notmuch-reply.c b/notmuch-reply.c
index 9ca1236..9d96ef1 100644
--- a/notmuch-reply.c
+++ b/notmuch-reply.c
@@ -354,6 +354,80 @@ notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_q
     }
     return 0;
 }
+static int
+notmuch_reply_format_sender_only(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
+{
+    GMimeMessage *reply;
+    notmuch_messages_t *messages;
+    notmuch_message_t *message;
+    const char *subject, *recipient, *from_addr = NULL;
+    const char *in_reply_to, *orig_references, *references;
+    char *reply_headers;
+
+    for (messages = notmuch_query_search_messages (query);
+	 notmuch_messages_has_more (messages);
+	 notmuch_messages_advance (messages))
+    {
+	message = notmuch_messages_get (messages);
+
+	/* The 1 means we want headers in a "pretty" order. */
+	reply = g_mime_message_new (1);
+	if (reply == NULL) {
+	    fprintf (stderr, "Out of memory\n");
+	    return 1;
+	}
+
+	subject = notmuch_message_get_header (message, "subject");
+
+	if (strncasecmp (subject, "Re:", 3))
+	    subject = talloc_asprintf (ctx, "Re: %s", subject);
+	g_mime_message_set_subject (reply, subject);
+
+	recipient = notmuch_message_get_header (message, "From");
+	g_mime_object_set_header (GMIME_OBJECT (reply),
+					"To", recipient);
+
+	from_addr = notmuch_config_get_user_primary_email (config);
+	from_addr = talloc_asprintf (ctx, "%s <%s>",
+				     notmuch_config_get_user_name (config),
+				     from_addr);
+	g_mime_object_set_header (GMIME_OBJECT (reply),
+				  "From", from_addr);
+
+	g_mime_object_set_header (GMIME_OBJECT (reply), "Bcc",
+			   notmuch_config_get_user_primary_email (config));
+
+	in_reply_to = talloc_asprintf (ctx, "<%s>",
+			     notmuch_message_get_message_id (message));
+
+	g_mime_object_set_header (GMIME_OBJECT (reply),
+				  "In-Reply-To", in_reply_to);
+
+	orig_references = notmuch_message_get_header (message, "references");
+	references = talloc_asprintf (ctx, "%s%s%s",
+				      orig_references ? orig_references : "",
+				      orig_references ? " " : "",
+				      in_reply_to);
+	g_mime_object_set_header (GMIME_OBJECT (reply),
+				  "References", references);
+
+	reply_headers = g_mime_object_to_string (GMIME_OBJECT (reply));
+	printf ("%s", reply_headers);
+	free (reply_headers);
+
+	g_object_unref (G_OBJECT (reply));
+	reply = NULL;
+
+	printf ("On %s, %s wrote:\n",
+		notmuch_message_get_header (message, "date"),
+		notmuch_message_get_header (message, "from"));
+
+	show_message_body (notmuch_message_get_filename (message), reply_part);
+
+	notmuch_message_destroy (message);
+    }
+    return 0;
+}
 
 int
 notmuch_reply_command (void *ctx, int argc, char *argv[])
@@ -378,6 +452,8 @@ notmuch_reply_command (void *ctx, int argc, char *argv[])
 		reply_format_func = notmuch_reply_format_default;
 	    } else if (strcmp (opt, "headers-only") == 0) {
 		reply_format_func = notmuch_reply_format_headers_only;
+	    } else if (strcmp (opt, "sender-only") == 0) {
+		reply_format_func = notmuch_reply_format_sender_only;
 	    } else {
 		fprintf (stderr, "Invalid value for --format: %s\n", opt);
 		return 1;
-- 
1.6.5.2.74.g610f9

[PATCH 2/2] notmuch.el: Add support for reply-to sender

[Aneesh Kumar K.V]

From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>

Add key binding to do a reply-to sender. This
is mapped to 'R'

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
---
 notmuch.el |   24 ++++++++++++++++++++++--
 1 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/notmuch.el b/notmuch.el
index bd8a6ce..c067e63 100644
--- a/notmuch.el
+++ b/notmuch.el
@@ -62,7 +62,8 @@
     (define-key map "s" 'notmuch-search)
     (define-key map "m" 'message-mail)
     (define-key map "f" 'notmuch-show-forward-current)
-    (define-key map "r" 'notmuch-show-reply)
+    (define-key map "r" 'notmuch-show-reply-all)
+    (define-key map "R" 'notmuch-show-reply)
     (define-key map "|" 'notmuch-show-pipe-message)
     (define-key map "w" 'notmuch-show-save-attachments)
     (define-key map "V" 'notmuch-show-view-raw-message)
@@ -367,12 +368,31 @@ buffer."
 	(forward-line)))
   (message-mode))
 
-(defun notmuch-show-reply ()
+(defun notmuch-show-reply-all ()
   "Begin composing a reply to the current message in a new buffer."
   (interactive)
   (let ((message-id (notmuch-show-get-message-id)))
     (notmuch-reply message-id)))
 
+
+(defun notmuch-format-reply (format-string query-string)
+  (switch-to-buffer (generate-new-buffer "notmuch-draft"))
+  (call-process notmuch-command nil t nil "reply" 
+		(concat "--format=" format-string) query-string)
+  (message-insert-signature)
+  (goto-char (point-min))
+  (if (re-search-forward "^$" nil t)
+      (progn
+	(insert "--text follows this line--")
+	(forward-line)))
+  (message-mode))
+
+(defun notmuch-show-reply ()
+  "Begin composing a reply to the current message in a new buffer."
+  (interactive)
+  (let ((message-id (notmuch-show-get-message-id)))
+    (notmuch-format-reply "sender-only" message-id)))
+
 (defun notmuch-show-forward-current ()
   "Forward the current message."
   (interactive)
-- 
1.6.5.2.74.g610f9

Re: [PATCH 1/2] notmuch-reply: Add support for replying only to sender

[Carl Worth]

[-- Attachment #1: Type: text/plain, Size: 372 bytes --]

On Thu,  3 Dec 2009 14:16:44 +0530, "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> wrote:
> From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
> 
> This patch add --format=sender-only option.

I like the idea here, (and agree that an 'R' keybinding would be great).

But surely there's a way to implement this with dramatically less code
duplication?

-Carl

[-- Attachment #2: Type: application/pgp-signature, Size: 189 bytes --]

Re: [PATCH 1/2] notmuch-reply: Add support for replying only to sender

[Jed Brown]

On Fri, 04 Dec 2009 11:07:54 -0800, Carl Worth <cworth@cworth.org> wrote:

> But surely there's a way to implement this with dramatically less code
> duplication?

It should just be very short after this series

  id:1259450376-24523-1-git-send-email-jed@59A2.org

I think --format= should not be used for this, formatting is orthogonal
to selecting recipients.

Speaking of code duplication, perhaps it is worth abstracting options
parsing (or using an existing library).

Jed

[PATCH -V2] notmuch-reply: Add support for replying only to sender

[Aneesh Kumar K.V]

From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>

This patch add --format=sender-only option.

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
---
 notmuch-reply.c |   54 ++++++++++++++++++++++++++++++++++++++++--------------
 1 files changed, 40 insertions(+), 14 deletions(-)

diff --git a/notmuch-reply.c b/notmuch-reply.c
index 0cda72d..859b725 100644
--- a/notmuch-reply.c
+++ b/notmuch-reply.c
@@ -23,15 +23,23 @@
 #include "notmuch-client.h"
 #include "gmime-filter-reply.h"
 
-static const struct {
+struct reply_map {
     const char *header;
     const char *fallback;
     GMimeRecipientType recipient_type;
-} reply_to_map[] = {
+};
+
+static const struct reply_map reply_to_all_map[] = {
     { "reply-to", "from", GMIME_RECIPIENT_TYPE_TO  },
     { "to",         NULL, GMIME_RECIPIENT_TYPE_TO  },
     { "cc",         NULL, GMIME_RECIPIENT_TYPE_CC  },
-    { "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC }
+    { "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC },
+    { NULL,         NULL, 0}
+};
+
+static const struct reply_map reply_to_sender_map[] = {
+    { "reply-to", "from", GMIME_RECIPIENT_TYPE_TO  },
+    { NULL,         NULL, 0}
 };
 
 static void
@@ -200,7 +208,8 @@ add_recipients_for_string (GMimeMessage *message,
 }
 
 static int
-notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
+__notmuch_reply(void *ctx, notmuch_config_t *config,
+		notmuch_query_t *query, const struct reply_map *map)
 {
     GMimeMessage *reply;
     notmuch_messages_t *messages;
@@ -229,17 +238,19 @@ notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_
 	    subject = talloc_asprintf (ctx, "Re: %s", subject);
 	g_mime_message_set_subject (reply, subject);
 
-	for (i = 0; i < ARRAY_SIZE (reply_to_map); i++) {
+	for (i = 0;; i++) {
 	    const char *addr;
 
+	    if (!map[i].header)
+		    break;
 	    recipients = notmuch_message_get_header (message,
-						     reply_to_map[i].header);
-	    if ((recipients == NULL || recipients[0] == '\0') && reply_to_map[i].fallback)
+						    map[i].header);
+	    if ((recipients == NULL || recipients[0] == '\0') && map[i].fallback)
 		recipients = notmuch_message_get_header (message,
-							 reply_to_map[i].fallback);
+							 map[i].fallback);
 
 	    addr = add_recipients_for_string (reply, config,
-					      reply_to_map[i].recipient_type,
+					      map[i].recipient_type,
 					      recipients);
 	    if (from_addr == NULL)
 		from_addr = addr;
@@ -289,6 +300,12 @@ notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_
     return 0;
 }
 
+static int
+notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
+{
+	return __notmuch_reply(ctx, config, query, reply_to_all_map);
+}
+
 /* This format is currently tuned for a git send-email --notmuch hook */
 static int
 notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
@@ -332,17 +349,18 @@ notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_q
 	g_mime_object_set_header (GMIME_OBJECT (reply),
 				  "References", references);
 
-	for (i = 0; i < ARRAY_SIZE (reply_to_map); i++) {
+	for (i = 0; i < ARRAY_SIZE (reply_to_all_map); i++) {
 	    const char *addr;
 
 	    recipients = notmuch_message_get_header (message,
-						     reply_to_map[i].header);
-	    if ((recipients == NULL || recipients[0] == '\0') && reply_to_map[i].fallback)
+						     reply_to_all_map[i].header);
+	    if ((recipients == NULL || recipients[0] == '\0') &&
+					reply_to_all_map[i].fallback)
 		recipients = notmuch_message_get_header (message,
-							 reply_to_map[i].fallback);
+						 reply_to_all_map[i].fallback);
 
 	    addr = add_recipients_for_string (reply, config,
-					      reply_to_map[i].recipient_type,
+					      reply_to_all_map[i].recipient_type,
 					      recipients);
 	}
 
@@ -361,6 +379,12 @@ notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_q
     return 0;
 }
 
+static int
+notmuch_reply_format_sender_only(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
+{
+	return __notmuch_reply(ctx, config, query, reply_to_sender_map);
+}
+
 int
 notmuch_reply_command (void *ctx, int argc, char *argv[])
 {
@@ -384,6 +408,8 @@ notmuch_reply_command (void *ctx, int argc, char *argv[])
 		reply_format_func = notmuch_reply_format_default;
 	    } else if (strcmp (opt, "headers-only") == 0) {
 		reply_format_func = notmuch_reply_format_headers_only;
+	    } else if (strcmp (opt, "sender-only") == 0) {
+		reply_format_func = notmuch_reply_format_sender_only;
 	    } else {
 		fprintf (stderr, "Invalid value for --format: %s\n", opt);
 		return 1;
-- 
1.6.5.2.74.g610f9

Re: [PATCH 1/2] notmuch-reply: Add support for replying only to sender

[Aneesh Kumar K. V]

On Fri, 04 Dec 2009 11:07:54 -0800, Carl Worth <cworth@cworth.org> wrote:
> On Thu,  3 Dec 2009 14:16:44 +0530, "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> wrote:
> > From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
> > 
> > This patch add --format=sender-only option.
> 
> I like the idea here, (and agree that an 'R' keybinding would be great).
> 
> But surely there's a way to implement this with dramatically less code
> duplication?

I sent an updated patch which did the above with less code duplication. Any
chance of getting this merged ?

-aneesh

Re: [PATCH 1/2] notmuch-reply: Add support for replying only to sender

[Carl Worth]

[-- Attachment #1: Type: text/plain, Size: 1259 bytes --]

On Fri, 11 Dec 2009 11:01:15 +0530, "Aneesh Kumar K. V" <aneesh.kumar@linux.vnet.ibm.com> wrote:
> On Fri, 04 Dec 2009 11:07:54 -0800, Carl Worth <cworth@cworth.org> wrote:
> > On Thu,  3 Dec 2009 14:16:44 +0530, "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com> wrote:
> > > 
> > > This patch add --format=sender-only option.
> > 
> > I like the idea here, (and agree that an 'R' keybinding would be great).
> > 
> > But surely there's a way to implement this with dramatically less code
> > duplication?
> 
> I sent an updated patch which did the above with less code duplication. Any
> chance of getting this merged ?

Thanks for the updated patch, (and I sincerely apologize for my late
response).

I still like the functionality and keybinding, and it's great to see
less code duplication in this patch, but I also agree with the point Jed
made:

  I think --format= should not be used for this, formatting is orthogonal
  to selecting recipients.

We're already using --format for selection JSON output, for example. And
it's not totally unreasonable to expect that someone might want JSON
output from "notmuch reply" as well. So let's use a separate option
here.

Perhaps:

	--recipient=all|sender

or so?

-Carl

[-- Attachment #2: Type: application/pgp-signature, Size: 189 bytes --]

[PATCH -V3 1/2] notmuch-reply: Add support for replying only to sender

[Aneesh Kumar K.V]

From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>

This patch add --recipient=all|sender option

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
---
 notmuch-client.h |    2 +
 notmuch-reply.c  |   55 ++++++++++++++++++++++++++++++++++++++++-------------
 2 files changed, 43 insertions(+), 14 deletions(-)

diff --git a/notmuch-client.h b/notmuch-client.h
index c80b39c..26fdb4a 100644
--- a/notmuch-client.h
+++ b/notmuch-client.h
@@ -70,6 +70,8 @@
 #define STRNCMP_LITERAL(var, literal) \
     strncmp ((var), (literal), sizeof (literal) - 1)
 
+#define NOTMUCH_REPLY_ALL   0x1
+#define NOTMUCH_REPLY_SENDER_ONLY 0x2
 static inline void
 chomp_newline (char *str)
 {
diff --git a/notmuch-reply.c b/notmuch-reply.c
index 6c15536..e8a0820 100644
--- a/notmuch-reply.c
+++ b/notmuch-reply.c
@@ -232,20 +232,37 @@ reply_to_header_is_redundant (notmuch_message_t *message)
 static const char *
 add_recipients_from_message (GMimeMessage *reply,
 			     notmuch_config_t *config,
-			     notmuch_message_t *message)
+			     notmuch_message_t *message,
+			     int reply_options)
 {
-    struct {
+    struct reply_to_map {
 	const char *header;
 	const char *fallback;
 	GMimeRecipientType recipient_type;
-    } reply_to_map[] = {
+    } ;
+    const char *from_addr = NULL;
+    unsigned int i;
+    struct reply_to_map *reply_to_map;
+
+    struct reply_to_map reply_to_map_all[] = {
 	{ "reply-to", "from", GMIME_RECIPIENT_TYPE_TO  },
 	{ "to",         NULL, GMIME_RECIPIENT_TYPE_TO  },
 	{ "cc",         NULL, GMIME_RECIPIENT_TYPE_CC  },
-	{ "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC }
+	{ "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC },
+	{  NULL,        NULL, 0 }
     };
-    const char *from_addr = NULL;
-    unsigned int i;
+
+    /* we try from first and then reply-to */
+    struct reply_to_map reply_to_map_sender[] = {
+	{ "from", "reply-to", GMIME_RECIPIENT_TYPE_TO  },
+	{  NULL,        NULL, 0 }
+    };
+
+    if (reply_options == NOTMUCH_REPLY_SENDER_ONLY) {
+	reply_to_map = reply_to_map_sender;
+    } else {
+	reply_to_map = reply_to_map_all;
+    }
 
     /* Some mailing lists munge the Reply-To header despite it being A Bad
      * Thing, see http://www.unicom.com/pw/reply-to-harmful.html
@@ -263,7 +280,7 @@ add_recipients_from_message (GMimeMessage *reply,
 	reply_to_map[0].fallback = NULL;
     }
 
-    for (i = 0; i < ARRAY_SIZE (reply_to_map); i++) {
+    for (i = 0; reply_to_map[i].header; i++) {
 	const char *addr, *recipients;
 
 	recipients = notmuch_message_get_header (message,
@@ -283,7 +300,7 @@ add_recipients_from_message (GMimeMessage *reply,
 }
 
 static int
-notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
+notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_t *query, int reply_options)
 {
     GMimeMessage *reply;
     notmuch_messages_t *messages;
@@ -311,7 +328,7 @@ notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_
 	    subject = talloc_asprintf (ctx, "Re: %s", subject);
 	g_mime_message_set_subject (reply, subject);
 
-	from_addr = add_recipients_from_message (reply, config, message);
+	from_addr = add_recipients_from_message (reply, config, message, reply_options);
 
 	if (from_addr == NULL)
 	    from_addr = notmuch_config_get_user_primary_email (config);
@@ -359,7 +376,7 @@ notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_
 
 /* This format is currently tuned for a git send-email --notmuch hook */
 static int
-notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
+notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_query_t *query, int reply_options)
 {
     GMimeMessage *reply;
     notmuch_messages_t *messages;
@@ -399,7 +416,7 @@ notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_q
 	g_mime_object_set_header (GMIME_OBJECT (reply),
 				  "References", references);
 
-	(void)add_recipients_from_message (reply, config, message);
+	(void)add_recipients_from_message (reply, config, message, reply_options);
 
 	g_mime_object_set_header (GMIME_OBJECT (reply), "Bcc",
 			   notmuch_config_get_user_primary_email (config));
@@ -423,8 +440,8 @@ notmuch_reply_command (void *ctx, int argc, char *argv[])
     notmuch_database_t *notmuch;
     notmuch_query_t *query;
     char *opt, *query_string;
-    int i, ret = 0;
-    int (*reply_format_func)(void *ctx, notmuch_config_t *config, notmuch_query_t *query);
+    int i, ret = 0, reply_to = NOTMUCH_REPLY_ALL;
+    int (*reply_format_func)(void *ctx, notmuch_config_t *config, notmuch_query_t *query, int reply_options);
 
     reply_format_func = notmuch_reply_format_default;
 
@@ -443,6 +460,16 @@ notmuch_reply_command (void *ctx, int argc, char *argv[])
 		fprintf (stderr, "Invalid value for --format: %s\n", opt);
 		return 1;
 	    }
+	} else if (STRNCMP_LITERAL (argv[i], "--recipient=") == 0) {
+	    opt = argv[i] + sizeof ("--recipient=") - 1;
+	    if (strcmp (opt, "all") == 0) {
+		reply_to = NOTMUCH_REPLY_ALL;
+	    } else if (strcmp (opt, "sender") == 0) {
+		reply_to = NOTMUCH_REPLY_SENDER_ONLY;
+	    } else {
+		fprintf (stderr, "Invalid value for --recipient: %s\n", opt);
+		return 1;
+	    }
 	} else {
 	    fprintf (stderr, "Unrecognized option: %s\n", argv[i]);
 	    return 1;
@@ -478,7 +505,7 @@ notmuch_reply_command (void *ctx, int argc, char *argv[])
 	return 1;
     }
 
-    if (reply_format_func (ctx, config, query) != 0)
+    if (reply_format_func (ctx, config, query, reply_to) != 0)
 	return 1;
 
     notmuch_query_destroy (query);
-- 
1.7.0.2.157.gb7e7f

[PATCH -V3 2/2] notmuch.el: Add support for reply-to sender

[Aneesh Kumar K.V]

From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>

Add key binding to do a reply-to sender. This is mapped to 'R'

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
---
 emacs/notmuch.el |   24 ++++++++++++++++++++++--
 1 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/emacs/notmuch.el b/emacs/notmuch.el
index 5b553bb..9ba1ec1 100644
--- a/emacs/notmuch.el
+++ b/emacs/notmuch.el
@@ -78,7 +78,8 @@
     (define-key map "s" 'notmuch-search)
     (define-key map "m" 'message-mail)
     (define-key map "f" 'notmuch-show-forward-current)
-    (define-key map "r" 'notmuch-show-reply)
+    (define-key map "r" 'notmuch-show-reply-all)
+    (define-key map "R" 'notmuch-show-reply)
     (define-key map "|" 'notmuch-show-pipe-message)
     (define-key map "w" 'notmuch-show-save-attachments)
     (define-key map "V" 'notmuch-show-view-raw-message)
@@ -446,12 +447,31 @@ buffer."
 	(forward-line)))
   (message-mode))
 
-(defun notmuch-show-reply ()
+(defun notmuch-show-reply-all ()
   "Begin composing a reply to the current message in a new buffer."
   (interactive)
   (let ((message-id (notmuch-show-get-message-id)))
     (notmuch-reply message-id)))
 
+
+(defun notmuch-recipient-reply (recipient query-string)
+  (switch-to-buffer (generate-new-buffer "notmuch-draft"))
+  (call-process notmuch-command nil t nil "reply"
+		(concat "--recipient=" recipient) query-string)
+  (message-insert-signature)
+  (goto-char (point-min))
+  (if (re-search-forward "^$" nil t)
+      (progn
+	(insert "--text follows this line--")
+	(forward-line)))
+  (message-mode))
+
+(defun notmuch-show-reply ()
+  "Begin composing a reply to the current message in a new buffer."
+  (interactive)
+  (let ((message-id (notmuch-show-get-message-id)))
+    (notmuch-recipient-reply "sender" message-id)))
+
 (defun notmuch-show-forward-current ()
   "Forward the current message."
   (interactive)
-- 
1.7.0.2.157.gb7e7f

Re: [PATCH -V3 1/2] notmuch-reply: Add support for replying only to sender

[Michal Sojka]

Hi,

On Wed, 10 Mar 2010, Aneesh Kumar K.V wrote:
> From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
> 
> This patch add --recipient=all|sender option
> 
> Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
> ---
>  notmuch-client.h |    2 +
>  notmuch-reply.c  |   55 ++++++++++++++++++++++++++++++++++++++++-------------
>  2 files changed, 43 insertions(+), 14 deletions(-)
> 
> diff --git a/notmuch-client.h b/notmuch-client.h
> index c80b39c..26fdb4a 100644
> --- a/notmuch-client.h
> +++ b/notmuch-client.h
> @@ -70,6 +70,8 @@
>  #define STRNCMP_LITERAL(var, literal) \
>      strncmp ((var), (literal), sizeof (literal) - 1)
>  
> +#define NOTMUCH_REPLY_ALL   0x1
> +#define NOTMUCH_REPLY_SENDER_ONLY 0x2

Why not to define this as enum? When I see a definition like this
it reminds me bit flags which can be used together e.g.
  (NOTMUCH_REPLY_ALL | NOTMUCH_REPLY_SENDER_ONLY).

This has obviously no sense here.

>  static inline void
>  chomp_newline (char *str)
>  {
> diff --git a/notmuch-reply.c b/notmuch-reply.c
> index 6c15536..e8a0820 100644
> --- a/notmuch-reply.c
> +++ b/notmuch-reply.c
> @@ -232,20 +232,37 @@ reply_to_header_is_redundant (notmuch_message_t *message)
>  static const char *
>  add_recipients_from_message (GMimeMessage *reply,
>  			     notmuch_config_t *config,
> -			     notmuch_message_t *message)
> +			     notmuch_message_t *message,
> +			     int reply_options)
>  {
> -    struct {
> +    struct reply_to_map {
>  	const char *header;
>  	const char *fallback;
>  	GMimeRecipientType recipient_type;
> -    } reply_to_map[] = {
> +    } ;
> +    const char *from_addr = NULL;
> +    unsigned int i;
> +    struct reply_to_map *reply_to_map;
> +
> +    struct reply_to_map reply_to_map_all[] = {
>  	{ "reply-to", "from", GMIME_RECIPIENT_TYPE_TO  },
>  	{ "to",         NULL, GMIME_RECIPIENT_TYPE_TO  },
>  	{ "cc",         NULL, GMIME_RECIPIENT_TYPE_CC  },
> -	{ "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC }
> +	{ "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC },
> +	{  NULL,        NULL, 0 }
>      };
> -    const char *from_addr = NULL;
> -    unsigned int i;
> +
> +    /* we try from first and then reply-to */
> +    struct reply_to_map reply_to_map_sender[] = {
> +	{ "from", "reply-to", GMIME_RECIPIENT_TYPE_TO  },
> +	{  NULL,        NULL, 0 }
> +    };

I'm not sure whether an e-mail without From: is a valid e-mail. If not,
you would never use "reply-to" header. Also, given the link below
(http://www.unicom.com/pw/reply-to-harmful.html), this will not behave
as Carl likes :). Finally, don't forget that reply_to_map can be
modified in add_recipients_from_message().

I missed your original patch so I implement this for myself in a less
intrusive way (see
id:1267464588-21050-1-git-send-email-sojkam1@fel.cvut.cz). What I like
at your approach is that --recipient option can have several values. I
think it would be useful to have three possible values of this option:
"all", "sender" and something like "reply-to-or-sender". The latter
option would cause using of Reply-to: header event if it is found as
redundant by reply_to_header_is_redundant(). I find this useful for
several private mailing lists I use.

-Michal
> +
> +    if (reply_options == NOTMUCH_REPLY_SENDER_ONLY) {
> +	reply_to_map = reply_to_map_sender;
> +    } else {
> +	reply_to_map = reply_to_map_all;
> +    }
>  
>      /* Some mailing lists munge the Reply-To header despite it being A Bad
>       * Thing, see http://www.unicom.com/pw/reply-to-harmful.html

[PATCH 1/2] notmuch-reply: Add support for replying only to sender

[Sebastian Spaeth]

From: Aneesh Kumar K.V <aneesh.kumar@gmail.com>

This patch add --recipient=all|sender option

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@gmail.com>
---
 notmuch-client.h |    2 +
 notmuch-reply.c  |   55 ++++++++++++++++++++++++++++++++++++++++-------------
 2 files changed, 43 insertions(+), 14 deletions(-)

diff --git a/notmuch-client.h b/notmuch-client.h
index d36b9ec..3ca4b32 100644
--- a/notmuch-client.h
+++ b/notmuch-client.h
@@ -73,6 +73,8 @@
 #define STRNCMP_LITERAL(var, literal) \
     strncmp ((var), (literal), sizeof (literal) - 1)
 
+#define NOTMUCH_REPLY_ALL   0x1
+#define NOTMUCH_REPLY_SENDER_ONLY 0x2
 static inline void
 chomp_newline (char *str)
 {
diff --git a/notmuch-reply.c b/notmuch-reply.c
index 6c15536..e8a0820 100644
--- a/notmuch-reply.c
+++ b/notmuch-reply.c
@@ -232,20 +232,37 @@ reply_to_header_is_redundant (notmuch_message_t *message)
 static const char *
 add_recipients_from_message (GMimeMessage *reply,
 			     notmuch_config_t *config,
-			     notmuch_message_t *message)
+			     notmuch_message_t *message,
+			     int reply_options)
 {
-    struct {
+    struct reply_to_map {
 	const char *header;
 	const char *fallback;
 	GMimeRecipientType recipient_type;
-    } reply_to_map[] = {
+    } ;
+    const char *from_addr = NULL;
+    unsigned int i;
+    struct reply_to_map *reply_to_map;
+
+    struct reply_to_map reply_to_map_all[] = {
 	{ "reply-to", "from", GMIME_RECIPIENT_TYPE_TO  },
 	{ "to",         NULL, GMIME_RECIPIENT_TYPE_TO  },
 	{ "cc",         NULL, GMIME_RECIPIENT_TYPE_CC  },
-	{ "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC }
+	{ "bcc",        NULL, GMIME_RECIPIENT_TYPE_BCC },
+	{  NULL,        NULL, 0 }
     };
-    const char *from_addr = NULL;
-    unsigned int i;
+
+    /* we try from first and then reply-to */
+    struct reply_to_map reply_to_map_sender[] = {
+	{ "from", "reply-to", GMIME_RECIPIENT_TYPE_TO  },
+	{  NULL,        NULL, 0 }
+    };
+
+    if (reply_options == NOTMUCH_REPLY_SENDER_ONLY) {
+	reply_to_map = reply_to_map_sender;
+    } else {
+	reply_to_map = reply_to_map_all;
+    }
 
     /* Some mailing lists munge the Reply-To header despite it being A Bad
      * Thing, see http://www.unicom.com/pw/reply-to-harmful.html
@@ -263,7 +280,7 @@ add_recipients_from_message (GMimeMessage *reply,
 	reply_to_map[0].fallback = NULL;
     }
 
-    for (i = 0; i < ARRAY_SIZE (reply_to_map); i++) {
+    for (i = 0; reply_to_map[i].header; i++) {
 	const char *addr, *recipients;
 
 	recipients = notmuch_message_get_header (message,
@@ -283,7 +300,7 @@ add_recipients_from_message (GMimeMessage *reply,
 }
 
 static int
-notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
+notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_t *query, int reply_options)
 {
     GMimeMessage *reply;
     notmuch_messages_t *messages;
@@ -311,7 +328,7 @@ notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_
 	    subject = talloc_asprintf (ctx, "Re: %s", subject);
 	g_mime_message_set_subject (reply, subject);
 
-	from_addr = add_recipients_from_message (reply, config, message);
+	from_addr = add_recipients_from_message (reply, config, message, reply_options);
 
 	if (from_addr == NULL)
 	    from_addr = notmuch_config_get_user_primary_email (config);
@@ -359,7 +376,7 @@ notmuch_reply_format_default(void *ctx, notmuch_config_t *config, notmuch_query_
 
 /* This format is currently tuned for a git send-email --notmuch hook */
 static int
-notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_query_t *query)
+notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_query_t *query, int reply_options)
 {
     GMimeMessage *reply;
     notmuch_messages_t *messages;
@@ -399,7 +416,7 @@ notmuch_reply_format_headers_only(void *ctx, notmuch_config_t *config, notmuch_q
 	g_mime_object_set_header (GMIME_OBJECT (reply),
 				  "References", references);
 
-	(void)add_recipients_from_message (reply, config, message);
+	(void)add_recipients_from_message (reply, config, message, reply_options);
 
 	g_mime_object_set_header (GMIME_OBJECT (reply), "Bcc",
 			   notmuch_config_get_user_primary_email (config));
@@ -423,8 +440,8 @@ notmuch_reply_command (void *ctx, int argc, char *argv[])
     notmuch_database_t *notmuch;
     notmuch_query_t *query;
     char *opt, *query_string;
-    int i, ret = 0;
-    int (*reply_format_func)(void *ctx, notmuch_config_t *config, notmuch_query_t *query);
+    int i, ret = 0, reply_to = NOTMUCH_REPLY_ALL;
+    int (*reply_format_func)(void *ctx, notmuch_config_t *config, notmuch_query_t *query, int reply_options);
 
     reply_format_func = notmuch_reply_format_default;
 
@@ -443,6 +460,16 @@ notmuch_reply_command (void *ctx, int argc, char *argv[])
 		fprintf (stderr, "Invalid value for --format: %s\n", opt);
 		return 1;
 	    }
+	} else if (STRNCMP_LITERAL (argv[i], "--recipient=") == 0) {
+	    opt = argv[i] + sizeof ("--recipient=") - 1;
+	    if (strcmp (opt, "all") == 0) {
+		reply_to = NOTMUCH_REPLY_ALL;
+	    } else if (strcmp (opt, "sender") == 0) {
+		reply_to = NOTMUCH_REPLY_SENDER_ONLY;
+	    } else {
+		fprintf (stderr, "Invalid value for --recipient: %s\n", opt);
+		return 1;
+	    }
 	} else {
 	    fprintf (stderr, "Unrecognized option: %s\n", argv[i]);
 	    return 1;
@@ -478,7 +505,7 @@ notmuch_reply_command (void *ctx, int argc, char *argv[])
 	return 1;
     }
 
-    if (reply_format_func (ctx, config, query) != 0)
+    if (reply_format_func (ctx, config, query, reply_to) != 0)
 	return 1;
 
     notmuch_query_destroy (query);
-- 
1.6.3.3