Re: gnus-search-engine set to gnus-search-notmuch and refer threads

[Eric Abrahamsen <eric@ericabrahamsen.net>]

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

"Jose A. Ortega Ruiz" <jao@gnu.org> writes:

> Hi again,
>
> So, summing up what we have so far (patch attached), the effect of these
> changes is to make the errors go away, but i'm not sure if the behaviour
> is expected: with the patch applied, A T will "work" for me in an
> nnselect group, with the caveat that, when gnus-refer-thread-use-search
> is t (or when calling gnus-refer-thread with C-u otherwise), the result
> is limited to the email already present in the nnselect group... that
> might be expected, in which case i think the patch can be applied (it's
> basically what you already propose, Eric, except it constructs the query
> as an alist).

Okay, here goes the next try. A few things to note:

- I realized notmuch already has a "thread:{<sub-query>}" syntax that
  does the double search I was doing in elisp, so now we just use that instead.
- In all my testing I couldn't see that having "duplicate=1" on thread
  searches causes any problems, so I've taken it off. Can you please
  doublecheck this? If it's still mucking it up for you, I'll put it
  back in. I wish I really understood what the problem is (I think it
  has to do with notmuch potentially storing the same message in
  multiple locations, using symlinks).
- The search result filtration now won't filter on group names if the
  search is a thread search. This should resolve the issue you were
  seeing where "A T" would only search within the group you had searched
  in to begin with. I guess I think that an explicit thread search by
  the user should result in a full scan of the server. We can see if
  that surprises/annoys anyone, though.

Thanks again,
Eric


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: notmuchthreads.diff --]
[-- Type: text/x-patch, Size: 3885 bytes --]

diff --git a/lisp/gnus/gnus-search.el b/lisp/gnus/gnus-search.el
index d64c0cb90c..4fb1fa3ec3 100644
--- a/lisp/gnus/gnus-search.el
+++ b/lisp/gnus/gnus-search.el
@@ -1352,7 +1352,10 @@ gnus-search-indexed-parse-output
 						server query &optional groups)
   (let ((prefix (or (slot-value engine 'remove-prefix)
                     ""))
-        (groups (mapcar #'gnus-group-short-name groups))
+        (groups (unless (alist-get 'thread query)
+                  ;; If we're searching threads, return messages from
+                  ;; all groups.
+                  (mapcar #'gnus-group-short-name groups)))
 	artlist article group)
     (goto-char (point-min))
     ;; Prep prefix, we want to at least be removing the root
@@ -1529,6 +1532,17 @@ gnus-search-transform
 				     (_query null))
   "*")
 
+(cl-defmethod gnus-search-make-query-string :around ((_engine gnus-search-notmuch)
+                                                     query-spec)
+  "Use Notmuch's thread:{<sub-query>} syntax.
+This packs the whole original query into <sub-query>, then
+returns all threads containing all matched messages."
+  (let ((query-string (cl-call-next-method))
+        (threadp (alist-get 'thread query-spec)))
+    (if threadp
+        (format "thread:{%s}" query-string)
+      query-string)))
+
 (cl-defmethod gnus-search-transform-expression ((engine gnus-search-notmuch)
 						(expr (head near)))
   (format "%s near %s"
@@ -1586,55 +1600,22 @@ gnus-search-transform-expression
       (format "date:%s.." (notmuch-date (cdr expr))))
      (t (ignore-errors (cl-call-next-method))))))
 
-(cl-defmethod gnus-search-run-search :around ((engine gnus-search-notmuch)
-					      server query groups)
-  "Handle notmuch's thread-search routine."
-  ;; Notmuch allows for searching threads, but only using its own
-  ;; thread ids.  That means a thread search is a \"double-bounce\":
-  ;; once to find the relevant thread ids, and again to find the
-  ;; actual messages.  This method performs the first \"bounce\".
-  (if (alist-get 'thread query)
-      (with-slots (program proc-buffer) engine
-	(let* ((qstring
-		(gnus-search-make-query-string engine query))
-	       (cp-list (gnus-search-indexed-search-command
-			 engine qstring query groups))
-	       thread-ids proc)
-	  (set-buffer proc-buffer)
-	  (erase-buffer)
-	  (setq proc (apply #'start-process (format "search-%s" server)
-			    proc-buffer program cp-list))
-	  (while (process-live-p proc)
-	    (accept-process-output proc))
-	  (while (re-search-forward "^thread:\\([^ ]+\\)" (point-max) t)
-	    (push (match-string 1) thread-ids))
-	  (cl-call-next-method
-	   engine server
-	   ;; Completely replace the query with our new thread-based one.
-	   (mapconcat (lambda (thrd) (concat "thread:" thrd))
-		      thread-ids " or ")
-	   nil)))
-    (cl-call-next-method engine server query groups)))
-
 (cl-defmethod gnus-search-indexed-search-command ((engine gnus-search-notmuch)
 						  (qstring string)
 						  query &optional _groups)
   ;; Theoretically we could use the GROUPS parameter to pass a
   ;; --folder switch to notmuch, but I'm not confident of getting the
   ;; format right.
-  (let ((limit (alist-get 'limit query))
-	(thread (alist-get 'thread query)))
+  (let ((limit (alist-get 'limit query)))
     (with-slots (switches config-file) engine
-      `(,(format "--config=%s" config-file)
-	"search"
-	,(if thread
-	     "--output=threads"
-	   "--output=files")
-	"--duplicate=1" ; I have found this necessary, I don't know why.
-	,@switches
-	,(if limit (format "--limit=%d" limit) "")
-	,qstring
-	))))
+      (append
+       (list (format "--config=%s" config-file)
+             "search"
+             "--output=files"
+             "--duplicate=1")
+       (when limit (list (format "--limit=%d" limit)))
+       switches
+       (list qstring)))))
 
 ;;; Mairix interface