X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch.el;h=b21aeaea4c68a8705c85aa4db75a55d2e77b58df;hp=af0c487e14d6664accb53ba19dbe3cef27ebd997;hb=f5e125a9c02c0afbe52d0be4033fb46e0d74dfc0;hpb=daeda152b8cdb662100129385212175b425c33c5 diff --git a/notmuch.el b/notmuch.el index af0c487e..b21aeaea 100644 --- a/notmuch.el +++ b/notmuch.el @@ -49,6 +49,7 @@ (require 'cl) (require 'mm-view) +(require 'message) (defvar notmuch-show-mode-map (let ((map (make-sparse-keymap))) @@ -61,7 +62,7 @@ ; overlays-at to query and manipulate the current overlay. (define-key map "a" 'notmuch-show-archive-thread) (define-key map "A" 'notmuch-show-mark-read-then-archive-thread) - (define-key map "b" 'notmuch-show-toggle-body-read-visible) + (define-key map "f" 'notmuch-show-forward-current) (define-key map "m" 'message-mail) (define-key map "n" 'notmuch-show-next-message) (define-key map "N" 'notmuch-show-mark-read-then-next-open-message) @@ -70,15 +71,17 @@ (define-key map (kbd "C-p") 'notmuch-show-previous-line) (define-key map "q" 'kill-this-buffer) (define-key map "r" 'notmuch-show-reply) + (define-key map "s" 'notmuch-search) (define-key map "v" 'notmuch-show-view-all-mime-parts) - (define-key map "w" 'notmuch-show-view-raw-message) + (define-key map "V" 'notmuch-show-view-raw-message) + (define-key map "w" 'notmuch-show-save-attachments) (define-key map "x" 'kill-this-buffer) (define-key map "+" 'notmuch-show-add-tag) (define-key map "-" 'notmuch-show-remove-tag) (define-key map (kbd "DEL") 'notmuch-show-rewind) (define-key map " " 'notmuch-show-advance-marking-read-and-archiving) (define-key map "|" 'notmuch-show-pipe-message) - (define-key map "?" 'describe-mode) + (define-key map "?" 'notmuch-help) (define-key map (kbd "TAB") 'notmuch-show-next-button) (define-key map (kbd "M-TAB") 'notmuch-show-previous-button) map) @@ -138,6 +141,13 @@ within the current window." (or (memq prop buffer-invisibility-spec) (assq prop buffer-invisibility-spec))))) +(defun notmuch-select-tag-with-completion (prompt &rest search-terms) + (let ((tag-list + (with-output-to-string + (with-current-buffer standard-output + (apply 'call-process notmuch-command nil t nil "search-tags" search-terms))))) + (completing-read prompt (split-string tag-list "\n+" t) nil nil nil))) + (defun notmuch-show-next-line () "Like builtin `next-line' but ensuring we end on a visible character. @@ -168,7 +178,7 @@ Unlike builtin `next-line' this version accepts no arguments." (if (not (looking-at notmuch-show-message-begin-regexp)) (re-search-backward notmuch-show-message-begin-regexp)) (re-search-forward notmuch-show-id-regexp) - (buffer-substring (match-beginning 1) (match-end 1)))) + (buffer-substring-no-properties (match-beginning 1) (match-end 1)))) (defun notmuch-show-get-filename () (save-excursion @@ -176,7 +186,7 @@ Unlike builtin `next-line' this version accepts no arguments." (if (not (looking-at notmuch-show-message-begin-regexp)) (re-search-backward notmuch-show-message-begin-regexp)) (re-search-forward notmuch-show-filename-regexp) - (buffer-substring (match-beginning 1) (match-end 1)))) + (buffer-substring-no-properties (match-beginning 1) (match-end 1)))) (defun notmuch-show-set-tags (tags) (save-excursion @@ -201,7 +211,8 @@ Unlike builtin `next-line' this version accepts no arguments." (defun notmuch-show-add-tag (&rest toadd) "Add a tag to the current message." - (interactive "sTag to add: ") + (interactive + (list (notmuch-select-tag-with-completion "Tag to add: "))) (apply 'notmuch-call-notmuch-process (append (cons "tag" (mapcar (lambda (s) (concat "+" s)) toadd)) @@ -210,7 +221,8 @@ Unlike builtin `next-line' this version accepts no arguments." (defun notmuch-show-remove-tag (&rest toremove) "Remove a tag from the current message." - (interactive "sTag to remove: ") + (interactive + (list (notmuch-select-tag-with-completion "Tag to remove: " (notmuch-show-get-message-id)))) (let ((tags (notmuch-show-get-tags))) (if (intersection tags toremove :test 'string=) (progn @@ -273,17 +285,62 @@ buffer." (interactive) (view-file (notmuch-show-get-filename))) +(defmacro with-current-notmuch-show-message (&rest body) + "Evaluate body with current buffer set to the text of current message" + `(save-excursion + (let ((filename (notmuch-show-get-filename))) + (let ((buf (generate-new-buffer (concat "*notmuch-msg-" filename "*")))) + (with-current-buffer buf + (insert-file-contents filename nil nil nil t) + ,@body) + (kill-buffer buf))))) + (defun notmuch-show-view-all-mime-parts () "Use external viewers (according to mailcap) to view all MIME-encoded parts." (interactive) - (save-excursion - (let ((filename (notmuch-show-get-filename))) - (switch-to-buffer (generate-new-buffer (concat "*notmuch-mime-" - filename - "*"))) - (insert-file-contents filename nil nil nil t) - (mm-display-parts (mm-dissect-buffer)) - (kill-this-buffer)))) + (with-current-notmuch-show-message + (mm-display-parts (mm-dissect-buffer)))) + +(defun notmuch-foreach-mime-part (function mm-handle) + (cond ((stringp (car mm-handle)) + (dolist (part (cdr mm-handle)) + (notmuch-foreach-mime-part function part))) + ((bufferp (car mm-handle)) + (funcall function mm-handle)) + (t (dolist (part mm-handle) + (notmuch-foreach-mime-part function part))))) + +(defun notmuch-count-attachments (mm-handle) + (let ((count 0)) + (notmuch-foreach-mime-part + (lambda (p) + (let ((disposition (mm-handle-disposition p))) + (and (listp disposition) + (equal (car disposition) "attachment") + (incf count)))) + mm-handle) + count)) + +(defun notmuch-save-attachments (mm-handle &optional queryp) + (notmuch-foreach-mime-part + (lambda (p) + (let ((disposition (mm-handle-disposition p))) + (and (listp disposition) + (equal (car disposition) "attachment") + (or (not queryp) + (y-or-n-p + (concat "Save '" (cdr (assq 'filename disposition)) "' "))) + (mm-save-part p)))) + mm-handle)) + +(defun notmuch-show-save-attachments () + "Save the attachments to a message" + (interactive) + (with-current-notmuch-show-message + (let ((mm-handle (mm-dissect-buffer))) + (notmuch-save-attachments + mm-handle (> (notmuch-count-attachments mm-handle) 1)))) + (message "Done")) (defun notmuch-reply (query-string) (switch-to-buffer (generate-new-buffer "notmuch-draft")) @@ -302,6 +359,12 @@ buffer." (let ((message-id (notmuch-show-get-message-id))) (notmuch-reply message-id))) +(defun notmuch-show-forward-current () + "Forward a the current message." + (interactive) + (with-current-notmuch-show-message + (message-forward))) + (defun notmuch-show-pipe-message (command) "Pipe the contents of the current message to the given command. @@ -555,29 +618,52 @@ which this thread was originally shown." (goto-char end)))))) (forward-line)))) -(defun notmuch-show-markup-part (beg end depth) +(defun notmuch-show-markup-part (beg end depth mime-message) (if (re-search-forward notmuch-show-part-begin-regexp nil t) (progn + (if (eq mime-message nil) + (let ((filename (notmuch-show-get-filename))) + (with-temp-buffer + (insert-file-contents filename nil nil nil t) + (setq mime-message (mm-dissect-buffer))))) (forward-line) - (let ((beg (point-marker))) + (let ((part-beg (point-marker))) (re-search-forward notmuch-show-part-end-regexp) - (let ((end (copy-marker (match-beginning 0)))) - (goto-char end) + + (let ((part-end (copy-marker (match-beginning 0)))) + (goto-char part-end) (if (not (bolp)) (insert "\n")) - (indent-rigidly beg end depth) - (notmuch-show-markup-citations-region beg end depth) + (indent-rigidly part-beg part-end depth) + (save-excursion + (goto-char part-beg) + (forward-line -1) + (beginning-of-line) + (let ((handle-type (mm-handle-type mime-message)) + mime-type) + (if (sequencep (car handle-type)) + (setq mime-type (car handle-type)) + (setq mime-type (car (car (cdr handle-type)))) + ) + (if (equal mime-type "text/html") + (mm-display-part mime-message)))) + + (notmuch-show-markup-citations-region part-beg part-end depth) ; Advance to the next part (if any) (so the outer loop can ; determine whether we've left the current message. (if (re-search-forward notmuch-show-part-begin-regexp nil t) (beginning-of-line))))) - (goto-char end))) + (goto-char end)) + mime-message) (defun notmuch-show-markup-parts-region (beg end depth) (save-excursion (goto-char beg) - (while (< (point) end) - (notmuch-show-markup-part beg end depth)))) + (let (mime-message) + (while (< (point) end) + (setq mime-message + (notmuch-show-markup-part + beg end depth mime-message)))))) (defun notmuch-show-markup-body (depth btn) (re-search-forward notmuch-show-body-begin-regexp) @@ -595,6 +681,32 @@ which this thread was originally shown." (set-marker beg nil) (set-marker end nil) ))) +(defun notmuch-fontify-headers () + (progn + (if (looking-at "[Tt]o:") + (progn + (overlay-put (make-overlay (point) (re-search-forward ":")) + 'face 'message-header-name) + (overlay-put (make-overlay (point) (re-search-forward ".*$")) + 'face 'message-header-to)) + (if (looking-at "[B]?[Cc][Cc]:") + (progn + (overlay-put (make-overlay (point) (re-search-forward ":")) + 'face 'message-header-name) + (overlay-put (make-overlay (point) (re-search-forward ".*$")) + 'face 'message-header-cc)) + (if (looking-at "[Ss]ubject:") + (progn + (overlay-put (make-overlay (point) (re-search-forward ":")) + 'face 'message-header-name) + (overlay-put (make-overlay (point) (re-search-forward ".*$")) + 'face 'message-header-subject)) + (if (looking-at "[Ff]rom:") + (progn + (overlay-put (make-overlay (point) (re-search-forward ":")) + 'face 'message-header-name) + (overlay-put (make-overlay (point) (re-search-forward ".*$")) + 'face 'message-header-other)))))))) (defun notmuch-show-markup-header (depth) (re-search-forward notmuch-show-header-begin-regexp) @@ -615,8 +727,7 @@ which this thread was originally shown." (forward-line) (while (looking-at "[A-Za-z][-A-Za-z0-9]*:") (beginning-of-line) - (overlay-put (make-overlay (point) (re-search-forward ":")) - 'face 'bold) + (notmuch-fontify-headers) (forward-line) ) (indent-rigidly beg end depth) @@ -664,6 +775,68 @@ which this thread was originally shown." (notmuch-show-markup-message))) (notmuch-show-hide-markers)) +(defun notmuch-documentation-first-line (symbol) + "Return the first line of the documentation string for SYMBOL." + (let ((doc (documentation symbol))) + (if doc + (with-temp-buffer + (insert (documentation symbol)) + (goto-char (point-min)) + (let ((beg (point))) + (end-of-line) + (buffer-substring beg (point)))) + ""))) + +(defun notmuch-prefix-key-description (key) + "Given a prefix key code, return a human-readable string representation. + +This is basically just `format-kbd-macro' but we also convert ESC to M-." + (let ((desc (format-kbd-macro (vector key)))) + (if (string= desc "ESC") + "M-" + (concat desc " ")))) + +; I would think that emacs would have code handy for walking a keymap +; and generating strings for each key, and I would prefer to just call +; that. But I couldn't find any (could be all implemented in C I +; suppose), so I wrote my own here. +(defun notmuch-substitute-one-command-key-with-prefix (prefix binding) + "For a key binding, return a string showing a human-readable +representation of the prefixed key as well as the first line of +documentation from the bound function. + +For a mouse binding, return nil." + (let ((key (car binding)) + (action (cdr binding))) + (if (mouse-event-p key) + nil + (if (keymapp action) + (let ((substitute (apply-partially 'notmuch-substitute-one-command-key-with-prefix (notmuch-prefix-key-description key)))) + (mapconcat substitute (cdr action) "\n")) + (concat prefix (format-kbd-macro (vector key)) + "\t" + (notmuch-documentation-first-line action)))))) + +(defalias 'notmuch-substitute-one-command-key + (apply-partially 'notmuch-substitute-one-command-key-with-prefix nil)) + +(defun notmuch-substitute-command-keys (doc) + "Like `substitute-command-keys' but with documentation, not function names." + (let ((beg 0)) + (while (string-match "\\\\{\\([^}[:space:]]*\\)}" doc beg) + (let ((map (substring doc (match-beginning 1) (match-end 1)))) + (setq doc (replace-match (mapconcat 'notmuch-substitute-one-command-key + (cdr (symbol-value (intern map))) "\n") 1 1 doc))) + (setq beg (match-end 0))) + doc)) + +(defun notmuch-help () + "Display help for the current notmuch mode." + (interactive) + (let ((mode major-mode)) + (with-help-window (help-buffer) + (princ (notmuch-substitute-command-keys (documentation mode t)))))) + ;;;###autoload (defun notmuch-show-mode () "Major mode for viewing a thread with notmuch. @@ -698,8 +871,6 @@ view, (remove the \"inbox\" tag from each), with mode-name "notmuch-show") (setq buffer-read-only t)) -;;;###autoload - (defgroup notmuch nil "Notmuch mail reader for Emacs." :group 'mail) @@ -768,7 +939,7 @@ thread from that buffer can be show when done with this one)." (setq btn (forward-button 1)) (error (setq btn nil))) )) - (beginning-of-buffer) + (goto-char (point-min)) )))) ))) @@ -777,46 +948,46 @@ thread from that buffer can be show when done with this one)." (defvar notmuch-search-mode-map (let ((map (make-sparse-keymap))) - (define-key map "a" 'notmuch-search-archive-thread) - (define-key map "b" 'notmuch-search-scroll-down) - (define-key map "f" 'notmuch-search-filter) - (define-key map "m" 'message-mail) - (define-key map "n" 'next-line) - (define-key map "o" 'notmuch-search-toggle-order) - (define-key map "p" 'previous-line) + (define-key map "?" 'notmuch-help) (define-key map "q" 'kill-this-buffer) + (define-key map "x" 'kill-this-buffer) + (define-key map (kbd "") 'notmuch-search-scroll-down) + (define-key map "b" 'notmuch-search-scroll-down) + (define-key map " " 'notmuch-search-scroll-up) + (define-key map "<" 'notmuch-search-first-thread) + (define-key map ">" 'notmuch-search-last-thread) + (define-key map "p" 'notmuch-search-previous-thread) + (define-key map "n" 'notmuch-search-next-thread) (define-key map "r" 'notmuch-search-reply-to-thread) + (define-key map "m" 'message-mail) (define-key map "s" 'notmuch-search) + (define-key map "o" 'notmuch-search-toggle-order) + (define-key map "=" 'notmuch-search-refresh-view) (define-key map "t" 'notmuch-search-filter-by-tag) - (define-key map "x" 'kill-this-buffer) - (define-key map (kbd "RET") 'notmuch-search-show-thread) + (define-key map "f" 'notmuch-search-filter) (define-key map [mouse-1] 'notmuch-search-show-thread) - (define-key map "+" 'notmuch-search-add-tag) + (define-key map "*" 'notmuch-search-operate-all) + (define-key map "a" 'notmuch-search-archive-thread) (define-key map "-" 'notmuch-search-remove-tag) - (define-key map "<" 'beginning-of-buffer) - (define-key map ">" 'notmuch-search-goto-last-thread) - (define-key map "=" 'notmuch-search-refresh-view) - (define-key map "\M->" 'notmuch-search-goto-last-thread) - (define-key map " " 'notmuch-search-scroll-up) - (define-key map (kbd "") 'notmuch-search-scroll-down) - (define-key map "?" 'describe-mode) + (define-key map "+" 'notmuch-search-add-tag) + (define-key map (kbd "RET") 'notmuch-search-show-thread) map) "Keymap for \"notmuch search\" buffers.") (fset 'notmuch-search-mode-map notmuch-search-mode-map) (defvar notmuch-search-query-string) -(defvar notmuch-search-oldest-first) - +(defvar notmuch-search-oldest-first t + "Show the oldest mail first in the search-mode") (defun notmuch-search-scroll-up () - "Scroll up, moving point to last message in thread if at end." + "Move forward through search results by one window's worth." (interactive) (condition-case nil (scroll-up nil) - ((end-of-buffer) (notmuch-search-goto-last-thread)))) + ((end-of-buffer) (notmuch-search-last-thread)))) (defun notmuch-search-scroll-down () - "Scroll down, moving point to first message in thread if at beginning." + "Move backward through the search results by one window's worth." (interactive) ; I don't know why scroll-down doesn't signal beginning-of-buffer ; the way that scroll-up signals end-of-buffer, but c'est la vie. @@ -826,34 +997,71 @@ thread from that buffer can be show when done with this one)." ; directly to that position. (We have to count lines since the ; window-start position is not the same as point-min due to the ; invisible thread-ID characters on the first line. - (if (equal (count-lines (point-min) (window-start)) 1) - (goto-char (window-start)) + (if (equal (count-lines (point-min) (window-start)) 0) + (goto-char (point-min)) (scroll-down nil))) -(defun notmuch-search-goto-last-thread () - "Move point to the last thread in the buffer." +(defun notmuch-search-next-thread () + "Select the next thread in the search results." + (interactive) + (next-line)) + +(defun notmuch-search-previous-thread () + "Select the previous thread in the search results." + (interactive) + (previous-line)) + +(defun notmuch-search-last-thread () + "Select the last thread in the search results." (interactive) (goto-char (point-max)) - (forward-line -1)) + (forward-line -2)) + +(defun notmuch-search-first-thread () + "Select the first thread in the search results." + (interactive) + (goto-char (point-min))) + +(defface notmuch-tag-face + '((((class color) + (background dark)) + (:foreground "OliveDrab1")) + (((class color) + (background light)) + (:foreground "navy blue" :bold t)) + (t + (:bold t))) + "Notmuch search mode face used to highligh tags." + :group 'notmuch) + +(defvar notmuch-tag-face-alist nil + "List containing the tag list that need to be highlighed") + +(defvar notmuch-search-font-lock-keywords nil) ;;;###autoload (defun notmuch-search-mode () - "Major mode for searching mail with notmuch. + "Major mode displaying results of a notmuch search. This buffer contains the results of a \"notmuch search\" of your email archives. Each line in the buffer represents a single -thread giving a relative date for the thread and a subject. +thread giving a summary of the thread (a relative date, the +number of matched messages and total messages in the thread, +participants in the thread, a representative subject line, and +any tags). + +By default, pressing RET on any line displays that thread. The +'+' and '-' keys can be used to add or remove tags from a +thread. The 'a' key is a convenience key for archiving a +thread (removing the \"inbox\" tag). The '*' key can be used to +add or remove a tag from all threads in the current buffer. -Pressing RET on any line displays that thread. The '+' and '-' -keys can be used to add or remove tags from a thread. The 'a' key -is a convenience key for archiving a thread (removing the -\"inbox\" tag). +Other useful commands are 'f' for filtering the current search +based on an additional query string, 't' for filtering to include +only messages with a given tag, and 's' to execute a new, global +search. -Other useful commands are `notmuch-search-filter' for filtering -the current search based on an additional query string, -`notmuch-search-filter-by-tag' for filtering to include only -messages with a given tag, and `notmuch-search' to execute a new, -global search. +Complete list of currently available key bindings: \\{notmuch-search-mode-map}" (interactive) @@ -866,41 +1074,25 @@ global search. (setq truncate-lines t) (setq major-mode 'notmuch-search-mode mode-name "notmuch-search") - (setq buffer-read-only t)) + (setq buffer-read-only t) + (if (not notmuch-tag-face-alist) + (add-to-list 'notmuch-search-font-lock-keywords (list + "(\\([^)]*\\))$" '(1 'notmuch-tag-face))) + (progn + (setq notmuch-search-tags (mapcar 'car notmuch-tag-face-alist)) + (loop for notmuch-search-tag in notmuch-search-tags + do (add-to-list 'notmuch-search-font-lock-keywords (list + (concat "([^)]*\\(" notmuch-search-tag "\\)[^)]*)$") + `(1 ,(cdr (assoc notmuch-search-tag notmuch-tag-face-alist)))))))) + (set (make-local-variable 'font-lock-defaults) + '(notmuch-search-font-lock-keywords t))) (defun notmuch-search-find-thread-id () - (save-excursion - (beginning-of-line) - (let ((beg (point))) - (re-search-forward "thread:[a-fA-F0-9]*" nil t) - (filter-buffer-substring beg (point))))) - -(defun notmuch-search-markup-this-thread-id () - (beginning-of-line) - (let ((beg (point))) - (if (re-search-forward "thread:[a-fA-F0-9]*" nil t) - (progn - (forward-char) - (overlay-put (make-overlay beg (point)) 'invisible 'notmuch-search) - (re-search-forward ".*\\[[0-9]*/[0-9]*\\] \\([^;]*\\)\\(;\\)") - (let* ((authors (buffer-substring (match-beginning 1) (match-end 1))) - (authors-length (length authors))) - ;; Drop the semi-colon - (replace-match "" t nil nil 2) - (if (<= authors-length notmuch-search-authors-width) - (replace-match (concat authors (make-string - (- notmuch-search-authors-width - authors-length) ? )) t t nil 1) - (replace-match (concat (substring authors 0 (- notmuch-search-authors-width 3)) "...") t t nil 1))))))) - -(defun notmuch-search-markup-thread-ids () - (save-excursion - (goto-char (point-min)) - (while (not (eobp)) - (notmuch-search-markup-this-thread-id) - (forward-line)))) + "Return the thread for the current thread" + (get-text-property (point) 'notmuch-search-thread-id)) (defun notmuch-search-show-thread () + "Display the currently selected thread." (interactive) (let ((thread-id (notmuch-search-find-thread-id))) (if (> (length thread-id) 0) @@ -953,23 +1145,105 @@ and will also appear in a buffer named \"*Notmuch errors*\"." (split-string (buffer-substring beg end)))))) (defun notmuch-search-add-tag (tag) - (interactive "sTag to add: ") - (notmuch-call-notmuch-process "tag" (concat "+" tag) (notmuch-search-find-thread-id)) + "Add a tag to the currently selected thread. + +The tag is added to messages in the currently selected thread +which match the current search terms." + (interactive + (list (notmuch-select-tag-with-completion "Tag to add: "))) + (notmuch-call-notmuch-process "tag" (concat "+" tag) (notmuch-search-find-thread-id) " and " notmuch-search-query-string) (notmuch-search-set-tags (delete-dups (sort (cons tag (notmuch-search-get-tags)) 'string<)))) (defun notmuch-search-remove-tag (tag) - (interactive "sTag to remove: ") - (notmuch-call-notmuch-process "tag" (concat "-" tag) (notmuch-search-find-thread-id)) + "Remove a tag from the currently selected thread. + +The tag is removed from messages in the currently selected thread +which match the current search terms." + (interactive + (list (notmuch-select-tag-with-completion "Tag to remove: " (notmuch-search-find-thread-id)))) + (notmuch-call-notmuch-process "tag" (concat "-" tag) (notmuch-search-find-thread-id) " and " notmuch-search-query-string) (notmuch-search-set-tags (delete tag (notmuch-search-get-tags)))) (defun notmuch-search-archive-thread () - "Archive the current thread (remove its \"inbox\" tag). + "Archive the currently selected thread (remove its \"inbox\" tag). -This function advances point to the next line when finished." +This function advances the next thread when finished." (interactive) (notmuch-search-remove-tag "inbox") (forward-line)) +(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))) + (if (memq status '(exit signal)) + (if (buffer-live-p buffer) + (with-current-buffer buffer + (save-excursion + (let ((inhibit-read-only t)) + (goto-char (point-max)) + (if (eq status 'signal) + (insert "Incomplete search results (search process was killed).\n")) + (if (eq status 'exit) + (progn + (insert "End of search results.") + (if (not (= exit-status 0)) + (insert (format " (process returned %d)" exit-status))) + (insert "\n")))))))))) + +(defun notmuch-search-process-filter (proc string) + "Process and filter the output of \"notmuch search\"" + (let ((buffer (process-buffer proc))) + (if (buffer-live-p buffer) + (with-current-buffer buffer + (save-excursion + (let ((line 0) + (more t) + (inhibit-read-only t)) + (while more + (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)) + (authors-length (length authors)) + (subject (match-string 5 string)) + (tags (match-string 6 string))) + (if (> authors-length 40) + (set 'authors (concat (substring authors 0 (- 40 3)) "..."))) + (goto-char (point-max)) + (let ((beg (point-marker))) + (insert (format "%s %-7s %-40s %s (%s)\n" date count authors subject tags)) + (put-text-property beg (point-marker) 'notmuch-search-thread-id thread-id)) + (set 'line (match-end 0))) + (set 'more nil)))))) + (delete-process proc)))) + +(defun notmuch-search-operate-all (action) + "Add/remove tags from all matching messages. + +Tis 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 "sOperation (+add -drop): notmuch tag ") + (let ((action-split (split-string action " +"))) + ;; Perform some validation + (let ((words action-split)) + (when (null words) (error "No operation given")) + (while words + (unless (string-match-p "^[-+][-+_.[:word:]]+$" (car words)) + (error "Action must be of the form `+thistag -that_tag'")) + (setq words (cdr words)))) + (apply 'notmuch-call-notmuch-process "tag" + (append action-split (list notmuch-search-query-string) nil)))) + +;;;###autoload (defun notmuch-search (query &optional oldest-first) "Run \"notmuch search\" with the given query string and display results." (interactive "sNotmuch search: ") @@ -986,11 +1260,12 @@ This function advances point to the next line when finished." (erase-buffer) (goto-char (point-min)) (save-excursion - (if oldest-first - (call-process notmuch-command nil t nil "search" "--sort=oldest-first" query) - (call-process notmuch-command nil t nil "search" "--sort=newest-first" query)) - (notmuch-search-markup-thread-ids) - )) + (let ((proc (start-process-shell-command + "notmuch-search" buffer notmuch-command "search" + (if oldest-first "--sort=oldest-first" "--sort=newest-first") + (shell-quote-argument query)))) + (set-process-sentinel proc 'notmuch-search-process-sentinel) + (set-process-filter proc 'notmuch-search-process-filter)))) (run-hooks 'notmuch-search-hook))) (defun notmuch-search-refresh-view () @@ -1044,13 +1319,16 @@ current search results AND the additional query string provided." Runs a new search matching only messages that match both the current search results AND that are tagged with the given tag." - (interactive "sFilter by tag: ") + (interactive + (list (notmuch-select-tag-with-completion "Filter by tag: "))) (notmuch-search (concat notmuch-search-query-string " and tag:" tag) notmuch-search-oldest-first)) + +;;;###autoload (defun notmuch () "Run notmuch to display all mail with tag of 'inbox'" (interactive) - (notmuch-search "tag:inbox" t)) + (notmuch-search "tag:inbox" notmuch-search-oldest-first)) (setq mail-user-agent 'message-user-agent) @@ -1064,7 +1342,7 @@ current search results AND that are tagged with the given tag." (define-key map (kbd "RET") 'notmuch-folder-show-search) (define-key map "<" 'beginning-of-buffer) (define-key map "=" 'notmuch-folder) - (define-key map "?" 'describe-mode) + (define-key map "?" 'notmuch-help) (define-key map [mouse-1] 'notmuch-folder-show-search) map) "Keymap for \"notmuch folder\" buffers.") @@ -1120,8 +1398,9 @@ results for the search terms in that line. (setq folder (notmuch-folder-find-name))) (let ((search (assoc folder notmuch-folders))) (if search - (notmuch-search (cdr search) t)))) + (notmuch-search (cdr search) notmuch-search-oldest-first)))) +;;;###autoload (defun notmuch-folder () "Show the notmuch folder view and update the displayed counts." (interactive)