Split replies to go with originals

Split replies to go with originals

[Kai.Grossjohann]

Pre-alpha code alert!

I have now produced the following patch for
pgnus-0.42/lisp/nnmail.el.  It is truly horrible code, and almost not
tested at all, but it *has* worked for two messages now :-)

What does it do?

You manually put a message in the foo group (using B m, say).  Now,
you get a reply for that message, and naturally, you want to put it in
the foo group, too.  Here's some code which does this if you have
nnmail-treat-duplicates set to a non-nil value and if you use
nnmail-split-fancy.

I have the following in ~/.gnus:

,-----
| (setq nnmail-split-fancy
|       '(| (: nnmail-split-fancy-with-parent)
|           ---other-split-rules-go-here---
|        )
| )
`-----

This should be all you need to get going.  Please tell me if it works
for you, and also don't hesitate to make suggestions for
nnmail-cache-insert -- that's the most horrible part.

kai
-- 
Life is hard and then you die.

--- nnmail.el.ORIG	Wed Nov 11 09:59:27 1998
+++ nnmail.el	Wed Nov 11 20:51:34 1998
@@ -1484,12 +1484,59 @@
 
 (defun nnmail-cache-insert (id)
   (when nnmail-treat-duplicates
-    (unless (gnus-buffer-live-p nnmail-cache-buffer)
-      (nnmail-cache-open))
+    ;; Store some information about the group this message is written
+    ;; to.  This function might have been called from various places.
+    ;; Sometimes, a function up in the calling sequence has an
+    ;; argument GROUP which is bound to a string, the group name.  At
+    ;; other times, there is a function up in the calling sequence
+    ;; which has an argument GROUP-ART which is a list of pairs, and
+    ;; the car of a pair is a group name.  Should we check that the
+    ;; length of the list is equal to 1? -- kai
+    (let ((g nil))
+      (cond ((and (boundp 'group) group)
+             (setq g group))
+            ((and (boundp 'group-art) group-art (listp group-art))
+             (setq g (caar group-art)))
+            (t (setq g "")))
+      (unless (gnus-buffer-live-p nnmail-cache-buffer)
+        (nnmail-cache-open))
+      (save-excursion
+        (set-buffer nnmail-cache-buffer)
+        (goto-char (point-max))
+        (insert id "\t" g "\n")))))
+
+;; Fetch the group name corresponding to the message id stored in the
+;; cache.
+(defun nnmail-cache-fetch-group (id)
+  (when (and nnmail-treat-duplicates nnmail-cache-buffer)
     (save-excursion
       (set-buffer nnmail-cache-buffer)
       (goto-char (point-max))
-      (insert id "\n"))))
+      (when (search-backward id nil t)
+        (beginning-of-line)
+        (skip-chars-forward "^\n\r\t")
+        (unless (eolp)
+          (forward-char 1)
+          (buffer-substring (point)
+                            (progn (end-of-line) (point))))))))
+
+;; Function for nnmail-split-fancy: look up all references in the
+;; cache and if a match is found, return that group.
+(defun nnmail-split-fancy-with-parent ()
+  (let* ((refstr (or (message-fetch-field "references")
+                     (message-fetch-field "in-reply-to")))
+         (references nil)
+         (res nil))
+    (when refstr
+      (setq references (nreverse (gnus-split-references refstr)))
+      (unless (gnus-buffer-live-p nnmail-cache-buffer)
+        (nnmail-cache-open))
+      (mapcar (lambda (x)
+                (setq res (or (nnmail-cache-fetch-group x) res))
+                (when (string= "drafts" res)
+                  (setq res nil)))
+              references)
+      res)))
 
 (defun nnmail-cache-id-exists-p (id)
   (when nnmail-treat-duplicates

Re: Split replies to go with originals

[Terje Sannum]

Kai.Grossjohann@CS.Uni-Dortmund.DE writes:

> You manually put a message in the foo group (using B m, say).  Now,
> you get a reply for that message, and naturally, you want to put it in
> the foo group, too. 

I've taken a different approach to do this. I put the group my message
gets saved to (the Gcc field) into the message-id. That way I can find
the group to store a reply directly from the in-reply-to or references
fields. This will also work when the message is not in the
nnmail-cache, but will not split correctly if the original message has
been moved. I'm not sure what is best...

-- 
\\\\ Terje Sannum <ts@nextel.no>
//// Now playing: X Marks The Pedwalk / Drawback
.

Re: Split replies to go with originals

[Kai.Grossjohann]

>>>>> Terje Sannum <ts@nextel.no> writes:

  > I've taken a different approach to do this. I put the group my
  > message gets saved to (the Gcc field) into the message-id. That
  > way I can find the group to store a reply directly from the
  > in-reply-to or references fields. [...]

That's an interesting approach, too.  Maybe my approach has the
advantage that it also works when no message from me is involved.
I.e., I get a Cc of a message, which I put in the foo group, then
there is a followup from someone else, and that also gets put in the
foo group.  This would be an advantage of my method over yours.

OTOH, your method does not depend on the cache length to be large
enough.  Hmmm...

kai
-- 
Life is hard and then you die.

Re: Split replies to go with originals

[Terje Sannum]

Kai.Grossjohann@CS.Uni-Dortmund.DE writes:

> That's an interesting approach, too.  Maybe my approach has the
> advantage that it also works when no message from me is involved.
> I.e., I get a Cc of a message, which I put in the foo group, then
> there is a followup from someone else, and that also gets put in the
> foo group.  This would be an advantage of my method over yours.
> 
> OTOH, your method does not depend on the cache length to be large
> enough.  Hmmm...

If it is difficult to have an index of all messages, the best way
might be to combine these methods. First chech in the cache, then try
to get the group from the original message-id, and last use the
original split rules.

-- 
\\\\ Terje Sannum <ts@nextel.no>
//// Now playing: Various Artists / For The Masses
.

Re: Split replies to go with originals

[Wes Hardaker]

>>>>> On 11 Nov 1998 20:59:54 +0100, Kai.Grossjohann@CS.Uni-Dortmund.DE said:

Kai> You manually put a message in the foo group (using B m, say).
Kai> Now, you get a reply for that message, and naturally, you want to
Kai> put it in the foo group, too.  Here's some code which does this
Kai> if you have nnmail-treat-duplicates set to a non-nil value and if
Kai> you use nnmail-split-fancy.

Ok.  I'll bite.  I love loosing mail.  Wish me luck. :-)

-- 
"Ninjas aren't dangerous.  They're more afraid of you than you are of them."

Re: Split replies to go with originals

[Kai.Grossjohann]

Wes Hardaker <wjhardaker@ucdavis.edu> writes:

  > Ok.  I'll bite.  I love loosing mail.  Wish me luck. :-)

:-)

I suppose I should explain what's going on.  I just write the group
name for all groups into the .nnmail-cache file.  And when mail is
split, there's a lookup and that group is used.

Now, suppose you write a mail to nnmh+/tmp:foo, then foo will be
written to the file, and upon receiving a reply to that message, you
will have a new nnml:foo group (or nnfolder:foo, or whatever backend
mail is split to).

kai
-- 
Life is hard and then you die.

Re: Split replies to go with originals

[Kai.Grossjohann]

Here's a slightly improved patch.  It only saves group names that are
used during mail splitting now.  I think so, at least.

This patch is against pgnus 0.42.  Usage instructions are the same as
for the previous patch.

Let me know how it works for you.

kai
-- 
Life is hard and then you die.

--- nnmail.el.ORIG	Wed Nov 11 09:59:27 1998
+++ nnmail.el	Fri Nov 13 23:35:03 1998
@@ -1484,12 +1484,77 @@
 
 (defun nnmail-cache-insert (id)
   (when nnmail-treat-duplicates
-    (unless (gnus-buffer-live-p nnmail-cache-buffer)
-      (nnmail-cache-open))
+    ;; Store some information about the group this message is written
+    ;; to.  This function might have been called from various places.
+    ;; Sometimes, a function up in the calling sequence has an
+    ;; argument GROUP which is bound to a string, the group name.  At
+    ;; other times, there is a function up in the calling sequence
+    ;; which has an argument GROUP-ART which is a list of pairs, and
+    ;; the car of a pair is a group name.  Should we check that the
+    ;; length of the list is equal to 1? -- kai
+    (let ((g nil))
+      (cond ((and (boundp 'group) group)
+             (setq g group))
+            ((and (boundp 'group-art-list) group-art-list
+                  (listp group-art-list))
+             (setq g (caar group-art-list)))
+            ((and (boundp 'group-art) group-art (listp group-art))
+             (setq g (caar group-art)))
+            (t (setq g "")))
+      (unless (gnus-buffer-live-p nnmail-cache-buffer)
+        (nnmail-cache-open))
+      (save-excursion
+        (set-buffer nnmail-cache-buffer)
+        (goto-char (point-max))
+        (if (gnus-methods-equal-p gnus-command-method
+                                  (nnmail-cache-primary-mail-backend))
+            (insert id "\t" g "\n")
+          (insert id "\n"))))))
+
+(defun nnmail-cache-primary-mail-backend ()
+  (let ((be-list (cons gnus-select-method gnus-secondary-select-methods))
+        (be nil)
+        (res nil))
+    (while (and (null res) be-list)
+      (setq be (car be-list))
+      (setq be-list (cdr be-list))
+      (when (and (gnus-method-option-p be 'respool)
+                 (eval (intern (format "%s-get-new-mail" (car be)))))
+        (setq res be)))
+    res))
+
+;; Fetch the group name corresponding to the message id stored in the
+;; cache.
+(defun nnmail-cache-fetch-group (id)
+  (when (and nnmail-treat-duplicates nnmail-cache-buffer)
     (save-excursion
       (set-buffer nnmail-cache-buffer)
       (goto-char (point-max))
-      (insert id "\n"))))
+      (when (search-backward id nil t)
+        (beginning-of-line)
+        (skip-chars-forward "^\n\r\t")
+        (unless (eolp)
+          (forward-char 1)
+          (buffer-substring (point)
+                            (progn (end-of-line) (point))))))))
+
+;; Function for nnmail-split-fancy: look up all references in the
+;; cache and if a match is found, return that group.
+(defun nnmail-split-fancy-with-parent ()
+  (let* ((refstr (or (message-fetch-field "references")
+                     (message-fetch-field "in-reply-to")))
+         (references nil)
+         (res nil))
+    (when refstr
+      (setq references (nreverse (gnus-split-references refstr)))
+      (unless (gnus-buffer-live-p nnmail-cache-buffer)
+        (nnmail-cache-open))
+      (mapcar (lambda (x)
+                (setq res (or (nnmail-cache-fetch-group x) res))
+                (when (string= "drafts" res)
+                  (setq res nil)))
+              references)
+      res)))
 
 (defun nnmail-cache-id-exists-p (id)
   (when nnmail-treat-duplicates

Split replies to go with originals

[Kai.Grossjohann]

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

For a long time, I have wanted the following feature: after I have
manually moved a certain article to a certain group, I want all
followups (or replies) to that article to go to that same group
automatically.

Back in the sixties, I created the following patch which will enable
Gnus to do that.  I'm interested in you folks trying it out to see if
it works.  Lars has said that he's willing to add this feature to Gnus
but that he's going to rewrite the mail splitting thing.  Now that
he's rewritten mail fetching, I think this is a good time to once
again check whether this feature works, before actually integrating it
into the Gnus core.

What does the patch do?

Well, Gnus keeps a log of recently seen mail in ~/.nnmail-cache.  This
patch just adds the group name along with the message id, and then
there's a splitting function for nnmail-split-fancy which looks up
message ids in the In-Reply-To and References headers in that file to
find out the right group name.  The file format is
backward-compatible, i.e. you can continue to use your existing file;
the group name will be added to newly encountered messages.  And the
patch is smart enough to only put the group name in if it's a group in
the mail backend where mail is split to.  (This is also the part that
will need to be changed when mail splitting is improved.)

The patch is for pgnus 0.63 but still applies cleanly to 0.73, except
for an offset of some lines.

How do you use it?

You need not do anything for this to store the message ids in
~/.nnmail-cache.  The patch defines a function
nnmail-split-fancy-with-parent which can be invoked from
nnmail-split-fancy like so:

  (setq nnmail-split-fancy
        '(| (: nnmail-split-fancy-with-parent)
            ;; other splits go here
         ))

Modify as appropriate.

I'm interested in all kinds of feedback.

kai
-- 
Abort this operation?   [Abort]  [Cancel]


[-- Attachment #2: mail split patch --]
[-- Type: application/x-patch, Size: 3389 bytes --]