emacs: Fix notmuch-message-mark-replied.

[notmuch] / emacs / notmuch.el

diff --git a/emacs/notmuch.el b/emacs/notmuch.el
index 19206db5032507bddccaa010a2274a21aaed8e96..fabb7c0d8b3accc74508ccae2f5da891daeaf238 100644 (file)
--- a/emacs/notmuch.el
+++ b/emacs/notmuch.el
@@ -48,11 +48,11 @@
 ;; required, but is available from http://notmuchmail.org).
 
 (eval-when-compile (require 'cl))
 ;; required, but is available from http://notmuchmail.org).
 
 (eval-when-compile (require 'cl))

-(require 'crm)

 (require 'mm-view)
 (require 'message)
 
 (require 'notmuch-lib)
 (require 'mm-view)
 (require 'message)
 
 (require 'notmuch-lib)

+(require 'notmuch-tag)

 (require 'notmuch-show)
 (require 'notmuch-mua)
 (require 'notmuch-hello)
 (require 'notmuch-show)
 (require 'notmuch-mua)
 (require 'notmuch-hello)


@@ -60,7 +60,7 @@
 (require 'notmuch-message)
 
 (defcustom notmuch-search-result-format
 (require 'notmuch-message)
 
 (defcustom notmuch-search-result-format

-  `(("date" . "%s ")
+  `(("date" . "%12s ")

     ("count" . "%-7s ")
     ("authors" . "%-20s ")
     ("subject" . "%s ")
     ("count" . "%-7s ")
     ("authors" . "%-20s ")
     ("subject" . "%s ")


@@ -76,39 +76,6 @@ For example:
 (defvar notmuch-query-history nil
   "Variable to store minibuffer history for notmuch queries")
 
 (defvar notmuch-query-history nil
   "Variable to store minibuffer history for notmuch queries")
 

-(defun notmuch-tag-completions (&optional prefixes search-terms)
-  (let ((tag-list
-        (split-string
-         (with-output-to-string
-           (with-current-buffer standard-output
-             (apply 'call-process notmuch-command nil t
-                    nil "search-tags" search-terms)))
-         "\n+" t)))
-    (if (null prefixes)
-       tag-list
-      (apply #'append
-            (mapcar (lambda (tag)
-                      (mapcar (lambda (prefix)
-                                (concat prefix tag)) prefixes))
-                    tag-list)))))
-
-(defun notmuch-select-tag-with-completion (prompt &rest search-terms)
-  (let ((tag-list (notmuch-tag-completions nil search-terms)))
-    (completing-read prompt tag-list)))
-
-(defun notmuch-select-tags-with-completion (prompt &optional prefixes &rest search-terms)
-  (let ((tag-list (notmuch-tag-completions prefixes search-terms))
-       (crm-separator " ")
-       ;; By default, space is bound to "complete word" function.
-       ;; Re-bind it to insert a space instead.  Note that <tab>
-       ;; still does the completion.
-       (crm-local-completion-map
-        (let ((map (make-sparse-keymap)))
-          (set-keymap-parent map crm-local-completion-map)
-          (define-key map " " 'self-insert-command)
-          map)))
-    (delete "" (completing-read-multiple prompt tag-list))))
-

 (defun notmuch-foreach-mime-part (function mm-handle)
   (cond ((stringp (car mm-handle))
          (dolist (part (cdr mm-handle))
 (defun notmuch-foreach-mime-part (function mm-handle)
   (cond ((stringp (car mm-handle))
          (dolist (part (cdr mm-handle))


@@ -222,10 +189,17 @@ For a mouse binding, return nil."
       (set-buffer-modified-p nil)
       (view-buffer (current-buffer) 'kill-buffer-if-not-modified))))
 
       (set-buffer-modified-p nil)
       (view-buffer (current-buffer) 'kill-buffer-if-not-modified))))
 

-(defcustom notmuch-search-hook '(hl-line-mode)
+(require 'hl-line)
+
+(defun notmuch-hl-line-mode ()
+  (prog1 (hl-line-mode)
+    (when hl-line-overlay
+      (overlay-put hl-line-overlay 'priority 1))))
+
+(defcustom notmuch-search-hook '(notmuch-hl-line-mode)

   "List of functions to call when notmuch displays the search results."
   :type 'hook
   "List of functions to call when notmuch displays the search results."
   :type 'hook

-  :options '(hl-line-mode)
+  :options '(notmuch-hl-line-mode)

   :group 'notmuch-search
   :group 'notmuch-hooks)
 
   :group 'notmuch-search
   :group 'notmuch-hooks)
 


@@ -252,7 +226,7 @@ For a mouse binding, return nil."
     (define-key map "t" 'notmuch-search-filter-by-tag)
     (define-key map "f" 'notmuch-search-filter)
     (define-key map [mouse-1] 'notmuch-search-show-thread)
     (define-key map "t" 'notmuch-search-filter-by-tag)
     (define-key map "f" 'notmuch-search-filter)
     (define-key map [mouse-1] 'notmuch-search-show-thread)

-    (define-key map "*" 'notmuch-search-operate-all)
+    (define-key map "*" 'notmuch-search-tag-all)

     (define-key map "a" 'notmuch-search-archive-thread)
     (define-key map "-" 'notmuch-search-remove-tag)
     (define-key map "+" 'notmuch-search-add-tag)
     (define-key map "a" 'notmuch-search-archive-thread)
     (define-key map "-" 'notmuch-search-remove-tag)
     (define-key map "+" 'notmuch-search-add-tag)


@@ -401,7 +375,7 @@ any tags).
 Pressing \\[notmuch-search-show-thread] on any line displays that thread. The '\\[notmuch-search-add-tag]' and '\\[notmuch-search-remove-tag]'
 keys can be used to add or remove tags from a thread. The '\\[notmuch-search-archive-thread]' key
 is a convenience for archiving a thread (removing the \"inbox\"
 Pressing \\[notmuch-search-show-thread] on any line displays that thread. The '\\[notmuch-search-add-tag]' and '\\[notmuch-search-remove-tag]'
 keys can be used to add or remove tags from a thread. The '\\[notmuch-search-archive-thread]' key
 is a convenience for archiving a thread (removing the \"inbox\"

-tag). The '\\[notmuch-search-operate-all]' key can be used to add or remove a tag from all
+tag). The '\\[notmuch-search-tag-all]' key can be used to add or remove a tag from all

 threads in the current buffer.
 
 Other useful commands are '\\[notmuch-search-filter]' for filtering the current search
 threads in the current buffer.
 
 Other useful commands are '\\[notmuch-search-filter]' for filtering the current search


@@ -447,6 +421,10 @@ Complete list of currently available key bindings:
   "Return a list of threads for the current region"
   (notmuch-search-properties-in-region 'notmuch-search-thread-id beg end))
 
   "Return a list of threads for the current region"
   (notmuch-search-properties-in-region 'notmuch-search-thread-id beg end))
 

+(defun notmuch-search-find-thread-id-region-search (beg end)
+  "Return a search string for threads for the current region"
+  (mapconcat 'identity (notmuch-search-find-thread-id-region beg end) " or "))
+

 (defun notmuch-search-find-authors ()
   "Return the authors for the current thread"
   (get-text-property (point) 'notmuch-search-authors))
 (defun notmuch-search-find-authors ()
   "Return the authors for the current thread"
   (get-text-property (point) 'notmuch-search-authors))


@@ -463,18 +441,17 @@ Complete list of currently available key bindings:
   "Return a list of authors for the current region"
   (notmuch-search-properties-in-region 'notmuch-search-subject beg end))
 
   "Return a list of authors for the current region"
   (notmuch-search-properties-in-region 'notmuch-search-subject beg end))
 

-(defun notmuch-search-show-thread (&optional crypto-switch)
+(defun notmuch-search-show-thread ()

   "Display the currently selected thread."
   "Display the currently selected thread."

-  (interactive "P")
+  (interactive)

   (let ((thread-id (notmuch-search-find-thread-id))
   (let ((thread-id (notmuch-search-find-thread-id))

-       (subject (notmuch-prettify-subject (notmuch-search-find-subject))))
+       (subject (notmuch-search-find-subject)))

     (if (> (length thread-id) 0)
        (notmuch-show thread-id
                      (current-buffer)
                      notmuch-search-query-string
                      ;; Name the buffer based on the subject.
     (if (> (length thread-id) 0)
        (notmuch-show thread-id
                      (current-buffer)
                      notmuch-search-query-string
                      ;; Name the buffer based on the subject.

-                     (concat "*" (truncate-string-to-width subject 30 nil nil t) "*")
-                     crypto-switch)
+                     (concat "*" (truncate-string-to-width subject 30 nil nil t) "*"))

       (message "End of search results."))))
 
 (defun notmuch-search-reply-to-thread (&optional prompt-for-sender)
       (message "End of search results."))))
 
 (defun notmuch-search-reply-to-thread (&optional prompt-for-sender)


@@ -506,50 +483,6 @@ and will also appear in a buffer named \"*Notmuch errors*\"."
            (error (buffer-substring beg end))
            ))))))
 
            (error (buffer-substring beg end))
            ))))))
 

-(defun notmuch-tag (query &rest tags)
-  "Add/remove tags in TAGS to messages matching QUERY.
-
-TAGS should be a list of strings of the form \"+TAG\" or \"-TAG\" and
-QUERY should be a string containing the search-query.
-
-Note: Other code should always use this function alter tags of
-messages instead of running (notmuch-call-notmuch-process \"tag\" ..)
-directly, so that hooks specified in notmuch-before-tag-hook and
-notmuch-after-tag-hook will be run."
-  ;; Perform some validation
-  (when (null tags) (error "No tags given"))
-  (mapc (lambda (tag)
-         (unless (string-match-p "^[-+][-+_.[:word:]]+$" tag)
-           (error "Tag must be of the form `+this_tag' or `-that_tag'")))
-       tags)
-  (run-hooks 'notmuch-before-tag-hook)
-  (apply 'notmuch-call-notmuch-process
-        (append (list "tag") tags (list "--" query)))
-  (run-hooks 'notmuch-after-tag-hook))
-
-(defcustom notmuch-before-tag-hook nil
-  "Hooks that are run before tags of a message are modified.
-
-'tags' will contain the tags that are about to be added or removed as
-a list of strings of the form \"+TAG\" or \"-TAG\".
-'query' will be a string containing the search query that determines
-the messages that are about to be tagged"
-
-  :type 'hook
-  :options '(hl-line-mode)
-  :group 'notmuch-hooks)
-
-(defcustom notmuch-after-tag-hook nil
-  "Hooks that are run after tags of a message are modified.
-
-'tags' will contain the tags that were added or removed as
-a list of strings of the form \"+TAG\" or \"-TAG\".
-'query' will be a string containing the search query that determines
-the messages that were tagged"
-  :type 'hook
-  :options '(hl-line-mode)
-  :group 'notmuch-hooks)
-

 (defun notmuch-search-set-tags (tags)
   (save-excursion
     (end-of-line)
 (defun notmuch-search-set-tags (tags)
   (save-excursion
     (end-of-line)


@@ -571,7 +504,7 @@ the messages that were tagged"
     (let ((beg (+ (point) 1)))
       (re-search-forward ")")
       (let ((end (- (point) 1)))
     (let ((beg (+ (point) 1)))
       (re-search-forward ")")
       (let ((end (- (point) 1)))

-       (split-string (buffer-substring beg end))))))
+       (split-string (buffer-substring-no-properties beg end))))))

 
 (defun notmuch-search-get-tags-region (beg end)
   (save-excursion
 
 (defun notmuch-search-get-tags-region (beg end)
   (save-excursion


@@ -584,87 +517,54 @@ the messages that were tagged"
        (forward-line 1))
       output)))
 
        (forward-line 1))
       output)))
 

-(defun notmuch-search-add-tag-thread (tag)
-  (notmuch-search-add-tag-region tag (point) (point)))
-
-(defun notmuch-search-add-tag-region (tag beg end)
-  (let ((search-id-string (mapconcat 'identity (notmuch-search-find-thread-id-region beg end) " or ")))
-    (notmuch-tag search-id-string (concat "+" tag))
+(defun notmuch-search-tag-region (beg end &optional tag-changes)
+  "Change tags for threads in the given region."
+  (let ((search-string (notmuch-search-find-thread-id-region-search beg end)))
+    (setq tag-changes (funcall 'notmuch-tag search-string tag-changes))

     (save-excursion
       (let ((last-line (line-number-at-pos end))
            (max-line (- (line-number-at-pos (point-max)) 2)))
        (goto-char beg)
        (while (<= (line-number-at-pos) (min last-line max-line))
     (save-excursion
       (let ((last-line (line-number-at-pos end))
            (max-line (- (line-number-at-pos (point-max)) 2)))
        (goto-char beg)
        (while (<= (line-number-at-pos) (min last-line max-line))

-         (notmuch-search-set-tags (delete-dups (sort (cons tag (notmuch-search-get-tags)) 'string<)))
+         (notmuch-search-set-tags
+          (notmuch-update-tags (notmuch-search-get-tags) tag-changes))

          (forward-line))))))
 
          (forward-line))))))
 

-(defun notmuch-search-remove-tag-thread (tag)
-  (notmuch-search-remove-tag-region tag (point) (point)))
+(defun notmuch-search-tag (&optional tag-changes)
+  "Change tags for the currently selected thread or region.

 
 

-(defun notmuch-search-remove-tag-region (tag beg end)
-  (let ((search-id-string (mapconcat 'identity (notmuch-search-find-thread-id-region beg end) " or ")))
-    (notmuch-tag search-id-string (concat "-" tag))
-    (save-excursion
-      (let ((last-line (line-number-at-pos end))
-           (max-line (- (line-number-at-pos (point-max)) 2)))
-       (goto-char beg)
-       (while (<= (line-number-at-pos) (min last-line max-line))
-         (notmuch-search-set-tags (delete tag (notmuch-search-get-tags)))
-         (forward-line))))))
-
-(defun notmuch-search-add-tag (tag)
-  "Add a tag to the currently selected thread or region.
-
-The tag is added to all messages in the currently selected thread
-or threads in the current region."
-  (interactive
-   (list (notmuch-select-tag-with-completion "Tag to add: ")))
-  (save-excursion
-    (if (region-active-p)
-       (let* ((beg (region-beginning))
-              (end (region-end)))
-         (notmuch-search-add-tag-region tag beg end))
-      (notmuch-search-add-tag-thread tag))))
+See `notmuch-tag' for information on the format of TAG-CHANGES."
+  (interactive)
+  (let* ((beg (if (region-active-p) (region-beginning) (point)))
+        (end (if (region-active-p) (region-end) (point))))
+    (funcall 'notmuch-search-tag-region beg end tag-changes)))

 
 

-(defun notmuch-search-remove-tag (tag)
-  "Remove a tag from the currently selected thread or region.
+(defun notmuch-search-add-tag ()
+  "Same as `notmuch-search-tag' but sets initial input to '+'."
+  (interactive)
+  (notmuch-search-tag "+"))

 
 

-The tag is removed from all messages in the currently selected
-thread or threads in the current region."
-  (interactive
-   (list (notmuch-select-tag-with-completion
-         "Tag to remove: "
-         (if (region-active-p)
-             (mapconcat 'identity
-                        (notmuch-search-find-thread-id-region (region-beginning) (region-end))
-                        " ")
-           (notmuch-search-find-thread-id)))))
-  (save-excursion
-    (if (region-active-p)
-       (let* ((beg (region-beginning))
-              (end (region-end)))
-         (notmuch-search-remove-tag-region tag beg end))
-      (notmuch-search-remove-tag-thread tag))))
+(defun notmuch-search-remove-tag ()
+  "Same as `notmuch-search-tag' but sets initial input to '-'."
+  (interactive)
+  (notmuch-search-tag "-"))

 
 (defun notmuch-search-archive-thread ()
   "Archive the currently selected thread (remove its \"inbox\" tag).
 
 This function advances the next thread when finished."
   (interactive)
 
 (defun notmuch-search-archive-thread ()
   "Archive the currently selected thread (remove its \"inbox\" tag).
 
 This function advances the next thread when finished."
   (interactive)

-  (notmuch-search-remove-tag-thread "inbox")
+  (notmuch-search-tag '("-inbox"))

   (notmuch-search-next-thread))
 
   (notmuch-search-next-thread))
 

-(defvar notmuch-search-process-filter-data nil
-  "Data that has not yet been processed.")
-(make-variable-buffer-local 'notmuch-search-process-filter-data)
-

 (defun notmuch-search-process-sentinel (proc msg)
   "Add a message to let user know when \"notmuch search\" exits"
   (let ((buffer (process-buffer proc))
        (status (process-status proc))
        (exit-status (process-exit-status proc))
        (never-found-target-thread nil))
 (defun notmuch-search-process-sentinel (proc msg)
   "Add a message to let user know when \"notmuch search\" exits"
   (let ((buffer (process-buffer proc))
        (status (process-status proc))
        (exit-status (process-exit-status proc))
        (never-found-target-thread nil))

-    (if (memq status '(exit signal))
+    (when (memq status '(exit signal))
+       (kill-buffer (process-get proc 'parse-buf))

        (if (buffer-live-p buffer)
            (with-current-buffer buffer
              (save-excursion
        (if (buffer-live-p buffer)
            (with-current-buffer buffer
              (save-excursion


@@ -674,8 +574,6 @@ This function advances the next thread when finished."
                  (if (eq status 'signal)
                      (insert "Incomplete search results (search process was killed).\n"))
                  (when (eq status 'exit)
                  (if (eq status 'signal)
                      (insert "Incomplete search results (search process was killed).\n"))
                  (when (eq status 'exit)

-                   (if notmuch-search-process-filter-data
-                       (insert (concat "Error: Unexpected output from notmuch search:\n" notmuch-search-process-filter-data)))

                    (insert "End of search results.")
                    (unless (= exit-status 0)
                      (insert (format " (process returned %d)" exit-status)))
                    (insert "End of search results.")
                    (unless (= exit-status 0)
                      (insert (format " (process returned %d)" exit-status)))


@@ -688,18 +586,19 @@ This function advances the next thread when finished."
                  (goto-char (point-min))
                  (forward-line (1- notmuch-search-target-line))))))))
 
                  (goto-char (point-min))
                  (forward-line (1- notmuch-search-target-line))))))))
 

-(defcustom notmuch-search-line-faces nil
+(defcustom notmuch-search-line-faces '(("unread" :weight bold)
+                                      ("flagged" :foreground "blue"))

   "Tag/face mapping for line highlighting in notmuch-search.
 
 Here is an example of how to color search results based on tags.
  (the following text would be placed in your ~/.emacs file):
 
   "Tag/face mapping for line highlighting in notmuch-search.
 
 Here is an example of how to color search results based on tags.
  (the following text would be placed in your ~/.emacs file):
 

- (setq notmuch-search-line-faces '((\"delete\" . (:foreground \"red\"
+ (setq notmuch-search-line-faces '((\"deleted\" . (:foreground \"red\"

                                                  :background \"blue\"))
                                    (\"unread\" . (:foreground \"green\"))))
 
 The attributes defined for matching tags are merged, with later
                                                  :background \"blue\"))
                                    (\"unread\" . (:foreground \"green\"))))
 
 The attributes defined for matching tags are merged, with later

-attributes overriding earlier. A message having both \"delete\"
+attributes overriding earlier. A message having both \"deleted\"

 and \"unread\" tags with the above settings would have a green
 foreground and blue background."
   :type '(alist :key-type (string) :value-type (custom-face-edit))
 and \"unread\" tags with the above settings would have a green
 foreground and blue background."
   :type '(alist :key-type (string) :value-type (custom-face-edit))


@@ -803,93 +702,117 @@ non-authors is found, assume that all of the authors match."
          (overlay-put overlay 'isearch-open-invisible #'delete-overlay)))
       (insert padding))))
 
          (overlay-put overlay 'isearch-open-invisible #'delete-overlay)))
       (insert padding))))
 

-(defun notmuch-search-insert-field (field date count authors subject tags)
+(defun notmuch-search-insert-field (field format-string result)

   (cond
    ((string-equal field "date")
   (cond
    ((string-equal field "date")

-    (insert (propertize (format (cdr (assoc field notmuch-search-result-format)) date)
+    (insert (propertize (format format-string (plist-get result :date_relative))

                        'face 'notmuch-search-date)))
    ((string-equal field "count")
                        'face 'notmuch-search-date)))
    ((string-equal field "count")

-    (insert (propertize (format (cdr (assoc field notmuch-search-result-format)) count)
+    (insert (propertize (format format-string
+                               (format "[%s/%s]" (plist-get result :matched)
+                                       (plist-get result :total)))

                        'face 'notmuch-search-count)))
    ((string-equal field "subject")
                        'face 'notmuch-search-count)))
    ((string-equal field "subject")

-    (insert (propertize (format (cdr (assoc field notmuch-search-result-format)) subject)
+    (insert (propertize (format format-string (plist-get result :subject))

                        'face 'notmuch-search-subject)))
 
    ((string-equal field "authors")
                        'face 'notmuch-search-subject)))
 
    ((string-equal field "authors")

-    (notmuch-search-insert-authors (cdr (assoc field notmuch-search-result-format)) authors))
+    (notmuch-search-insert-authors format-string (plist-get result :authors)))

 
    ((string-equal field "tags")
 
    ((string-equal field "tags")

-    (insert (concat "(" (propertize tags 'font-lock-face 'notmuch-tag-face) ")")))))
+    ;; Ignore format-string here because notmuch-search-set-tags
+    ;; depends on the format of this
+    (insert (concat "(" (propertize
+                        (mapconcat 'identity (plist-get result :tags) " ")
+                        'font-lock-face 'notmuch-tag-face) ")")))))
+
+(defun notmuch-search-show-result (result)
+  ;; Ignore excluded matches
+  (unless (= (plist-get result :matched) 0)
+    (let ((beg (point-max)))
+      (save-excursion
+       (goto-char beg)
+       (dolist (spec notmuch-search-result-format)
+         (notmuch-search-insert-field (car spec) (cdr spec) result))
+       (insert "\n")
+       (notmuch-search-color-line beg (point) (plist-get result :tags))
+       (put-text-property beg (point) 'notmuch-search-thread-id
+                          (concat "thread:" (plist-get result :thread)))
+       (put-text-property beg (point) 'notmuch-search-authors
+                          (plist-get result :authors))
+       (put-text-property beg (point) 'notmuch-search-subject
+                          (plist-get result :subject)))
+      (when (string= (plist-get result :thread) notmuch-search-target-thread)
+       (setq notmuch-search-target-thread "found")
+       (goto-char beg)))))
+
+(defun notmuch-search-show-error (string &rest objects)
+  (save-excursion
+    (goto-char (point-max))
+    (insert "Error: Unexpected output from notmuch search:\n")
+    (insert (apply #'format string objects))
+    (insert "\n")))
+
+(defvar notmuch-search-process-state nil
+  "Parsing state of the search process filter.")

 
 

-(defun notmuch-search-show-result (date count authors subject tags)
-  (let ((fields) (field))
-    (setq fields (mapcar 'car notmuch-search-result-format))
-    (loop for field in fields
-         do (notmuch-search-insert-field field date count authors subject tags)))
-  (insert "\n"))
+(defvar notmuch-search-json-parser nil
+  "Incremental JSON parser for the search process filter.")

 
 (defun notmuch-search-process-filter (proc string)
   "Process and filter the output of \"notmuch search\""
 
 (defun notmuch-search-process-filter (proc string)
   "Process and filter the output of \"notmuch search\""

-  (let ((buffer (process-buffer proc))
-       (found-target nil))
-    (if (buffer-live-p buffer)
-       (with-current-buffer buffer
-         (save-excursion
-           (let ((line 0)
-                 (more t)
-                 (inhibit-read-only t)
-                 (string (concat notmuch-search-process-filter-data string)))
-             (setq notmuch-search-process-filter-data nil)
-             (while more
-               (while (and (< line (length string)) (= (elt string line) ?\n))
-                 (setq line (1+ line)))
-               (if (string-match "^\\(thread:[0-9A-Fa-f]*\\) \\([^][]*\\) \\(\\[[0-9/]*\\]\\) \\([^;]*\\); \\(.*\\) (\\([^()]*\\))$" string line)
-                   (let* ((thread-id (match-string 1 string))
-                          (date (match-string 2 string))
-                          (count (match-string 3 string))
-                          (authors (match-string 4 string))
-                          (subject (match-string 5 string))
-                          (tags (match-string 6 string))
-                          (tag-list (if tags (save-match-data (split-string tags)))))
-                     (goto-char (point-max))
-                     (if (/= (match-beginning 1) line)
-                         (insert (concat "Error: Unexpected output from notmuch search:\n" (substring string line (match-beginning 1)) "\n")))
-                     (let ((beg (point)))
-                       (notmuch-search-show-result date count authors
-                                                   (notmuch-prettify-subject subject) tags)
-                       (notmuch-search-color-line beg (point) tag-list)
-                       (put-text-property beg (point) 'notmuch-search-thread-id thread-id)
-                       (put-text-property beg (point) 'notmuch-search-authors authors)
-                       (put-text-property beg (point) 'notmuch-search-subject subject)
-                       (when (string= thread-id notmuch-search-target-thread)
-                         (set 'found-target beg)
-                         (set 'notmuch-search-target-thread "found")))
-                     (set 'line (match-end 0)))
-                 (set 'more nil)
-                 (while (and (< line (length string)) (= (elt string line) ?\n))
-                   (setq line (1+ line)))
-                 (if (< line (length string))
-                     (setq notmuch-search-process-filter-data (substring string line)))
-                 ))))
-         (if found-target
-             (goto-char found-target)))
-      (delete-process proc))))
-
-(defun notmuch-search-operate-all (&rest actions)
-  "Add/remove tags from all matching messages.
-
-This command adds or removes tags from all messages matching the
-current search terms. When called interactively, this command
-will prompt for tags to be added or removed. Tags prefixed with
-'+' will be added and tags prefixed with '-' will be removed.
-
-Each character of the tag name may consist of alphanumeric
-characters as well as `_.+-'.
-"
-  (interactive (notmuch-select-tags-with-completion
-               "Operations (+add -drop): notmuch tag "
-               '("+" "-")))
-  (apply 'notmuch-tag notmuch-search-query-string actions))
+  (let ((results-buf (process-buffer proc))
+       (parse-buf (process-get proc 'parse-buf))
+       (inhibit-read-only t)
+       done)
+    (if (not (buffer-live-p results-buf))
+       (delete-process proc)
+      (with-current-buffer parse-buf
+       ;; Insert new data
+       (save-excursion
+         (goto-char (point-max))
+         (insert string)))
+      (with-current-buffer results-buf
+       (while (not done)
+         (condition-case nil
+             (case notmuch-search-process-state
+               ((begin)
+                ;; Enter the results list
+                (if (eq (notmuch-json-begin-compound
+                         notmuch-search-json-parser) 'retry)
+                    (setq done t)
+                  (setq notmuch-search-process-state 'result)))
+               ((result)
+                ;; Parse a result
+                (let ((result (notmuch-json-read notmuch-search-json-parser)))
+                  (case result
+                    ((retry) (setq done t))
+                    ((end) (setq notmuch-search-process-state 'end))
+                    (otherwise (notmuch-search-show-result result)))))
+               ((end)
+                ;; Any trailing data is unexpected
+                (notmuch-json-eof notmuch-search-json-parser)
+                (setq done t)))
+           (json-error
+            ;; Do our best to resynchronize and ensure forward
+            ;; progress
+            (notmuch-search-show-error
+             "%s"
+             (with-current-buffer parse-buf
+               (let ((bad (buffer-substring (line-beginning-position)
+                                            (line-end-position))))
+                 (forward-line)
+                 bad))))))
+       ;; Clear out what we've parsed
+       (with-current-buffer parse-buf
+         (delete-region (point-min) (point)))))))
+
+(defun notmuch-search-tag-all (&optional tag-changes)
+  "Add/remove tags from all messages in current search buffer.
+
+See `notmuch-tag' for information on the format of TAG-CHANGES."
+  (interactive)
+  (apply 'notmuch-tag notmuch-search-query-string tag-changes))

 
 (defun notmuch-search-buffer-title (query)
   "Returns the title for a buffer with notmuch search results."
 
 (defun notmuch-search-buffer-title (query)
   "Returns the title for a buffer with notmuch search results."


@@ -944,7 +867,7 @@ PROMPT is the string to prompt with."
                                         completions)))
               (t (list string)))))))
       ;; this was simpler than convincing completing-read to accept spaces:
                                         completions)))
               (t (list string)))))))
       ;; this was simpler than convincing completing-read to accept spaces:

-      (define-key keymap (kbd "<tab>") 'minibuffer-complete)
+      (define-key keymap (kbd "TAB") 'minibuffer-complete)

       (let ((history-delete-duplicates t))
        (read-from-minibuffer prompt nil keymap nil
                              'notmuch-search-history nil nil)))))
       (let ((history-delete-duplicates t))
        (read-from-minibuffer prompt nil keymap nil
                              'notmuch-search-history nil nil)))))


@@ -985,10 +908,19 @@ Other optional parameters are used as follows:
        (let ((proc (start-process
                     "notmuch-search" buffer
                     notmuch-command "search"
        (let ((proc (start-process
                     "notmuch-search" buffer
                     notmuch-command "search"

+                    "--format=json"

                     (if oldest-first
                         "--sort=oldest-first"
                       "--sort=newest-first")
                     (if oldest-first
                         "--sort=oldest-first"
                       "--sort=newest-first")

-                    query)))
+                    query))
+             ;; Use a scratch buffer to accumulate partial output.
+             ;; This buffer will be killed by the sentinel, which
+             ;; should be called no matter how the process dies.
+             (parse-buf (generate-new-buffer " *notmuch search parse*")))
+         (set (make-local-variable 'notmuch-search-process-state) 'begin)
+         (set (make-local-variable 'notmuch-search-json-parser)
+              (notmuch-json-create-parser parse-buf))
+         (process-put proc 'parse-buf parse-buf)

          (set-process-sentinel proc 'notmuch-search-process-sentinel)
          (set-process-filter proc 'notmuch-search-process-filter)
          (set-process-query-on-exit-flag proc nil))))
          (set-process-sentinel proc 'notmuch-search-process-sentinel)
          (set-process-filter proc 'notmuch-search-process-filter)
          (set-process-query-on-exit-flag proc nil))))