emacs: Increase consistency of library headers
[notmuch] / emacs / notmuch-tag.el
1 ;;; notmuch-tag.el --- tag messages within emacs
2 ;;
3 ;; Copyright © Damien Cassou
4 ;; Copyright © Carl Worth
5 ;;
6 ;; This file is part of Notmuch.
7 ;;
8 ;; Notmuch is free software: you can redistribute it and/or modify it
9 ;; under the terms of the GNU General Public License as published by
10 ;; the Free Software Foundation, either version 3 of the License, or
11 ;; (at your option) any later version.
12 ;;
13 ;; Notmuch is distributed in the hope that it will be useful, but
14 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 ;; General Public License for more details.
17 ;;
18 ;; You should have received a copy of the GNU General Public License
19 ;; along with Notmuch.  If not, see <https://www.gnu.org/licenses/>.
20 ;;
21 ;; Authors: Carl Worth <cworth@cworth.org>
22 ;;          Damien Cassou <damien.cassou@gmail.com>
23
24 ;;; Code:
25
26 (require 'cl-lib)
27 (eval-when-compile
28   (require 'pcase))
29
30 (require 'crm)
31
32 (require 'notmuch-lib)
33
34 (declare-function notmuch-search-tag "notmuch"
35                   (tag-changes &optional beg end only-matched))
36 (declare-function notmuch-show-tag "notmuch-show" (tag-changes))
37 (declare-function notmuch-tree-tag "notmuch-tree" (tag-changes))
38 (declare-function notmuch-jump "notmuch-jump" (action-map prompt))
39
40 (define-widget 'notmuch-tag-key-type 'list
41   "A single key tagging binding."
42   :format "%v"
43   :args '((list :inline t
44                 :format "%v"
45                 (key-sequence :tag "Key")
46                 (radio :tag "Tag operations"
47                        (repeat :tag "Tag list"
48                                (string :format "%v" :tag "change"))
49                        (variable :tag "Tag variable"))
50                 (string :tag "Name"))))
51
52 (defcustom notmuch-tagging-keys
53   `((,(kbd "a") notmuch-archive-tags "Archive")
54     (,(kbd "u") notmuch-show-mark-read-tags "Mark read")
55     (,(kbd "f") ("+flagged") "Flag")
56     (,(kbd "s") ("+spam" "-inbox") "Mark as spam")
57     (,(kbd "d") ("+deleted" "-inbox") "Delete"))
58   "A list of keys and corresponding tagging operations.
59
60 For each key (or key sequence) you can specify a sequence of
61 tagging operations to apply, or a variable which contains a list
62 of tagging operations such as `notmuch-archive-tags'. The final
63 element is a name for this tagging operation. If the name is
64 omitted or empty then the list of tag changes, or the variable
65 name is used as the name.
66
67 The key `notmuch-tag-jump-reverse-key' (k by default) should not
68 be used (either as a key, or as the start of a key sequence) as
69 it is already bound: it switches the menu to a menu of the
70 reverse tagging operations. The reverse of a tagging operation is
71 the same list of individual tag-ops but with `+tag` replaced by
72 `-tag` and vice versa.
73
74 If setting this variable outside of customize then it should be a
75 list of triples (lists of three elements). Each triple should be
76 of the form (key-binding tagging-operations name). KEY-BINDING
77 can be a single character or a key sequence; TAGGING-OPERATIONS
78 should either be a list of individual tag operations each of the
79 form `+tag` or `-tag`, or the variable name of a variable that is
80 a list of tagging operations; NAME should be a name for the
81 tagging operation, if omitted or empty than then name is taken
82 from TAGGING-OPERATIONS."
83   :tag "List of tagging bindings"
84   :type '(repeat notmuch-tag-key-type)
85   :group 'notmuch-tag)
86
87 (define-widget 'notmuch-tag-format-type 'lazy
88   "Customize widget for notmuch-tag-format and friends."
89   :type '(alist :key-type (regexp :tag "Tag")
90                 :extra-offset -3
91                 :value-type
92                 (radio :format "%v"
93                        (const :tag "Hidden" nil)
94                        (set :tag "Modified"
95                             (string :tag "Display as")
96                             (list :tag "Face" :extra-offset -4
97                                   (const :format "" :inline t
98                                          (notmuch-apply-face tag))
99                                   (list :format "%v"
100                                         (const :format "" quote)
101                                         custom-face-edit))
102                             (list :format "%v" :extra-offset -4
103                                   (const :format "" :inline t
104                                          (notmuch-tag-format-image-data tag))
105                                   (choice :tag "Image"
106                                           (const :tag "Star"
107                                                  (notmuch-tag-star-icon))
108                                           (const :tag "Empty star"
109                                                  (notmuch-tag-star-empty-icon))
110                                           (const :tag "Tag"
111                                                  (notmuch-tag-tag-icon))
112                                           (string :tag "Custom")))
113                             (sexp :tag "Custom")))))
114
115 (defface notmuch-tag-unread
116   '((t :foreground "red"))
117   "Default face used for the unread tag.
118
119 Used in the default value of `notmuch-tag-formats`."
120   :group 'notmuch-faces)
121
122 (defface notmuch-tag-flagged
123   '((((class color)
124       (background dark))
125      (:foreground "LightBlue1"))
126     (((class color)
127       (background light))
128      (:foreground "blue")))
129   "Face used for the flagged tag.
130
131 Used in the default value of `notmuch-tag-formats`."
132   :group 'notmuch-faces)
133
134 (defcustom notmuch-tag-formats
135   '(("unread" (propertize tag 'face 'notmuch-tag-unread))
136     ("flagged" (propertize tag 'face 'notmuch-tag-flagged)
137      (notmuch-tag-format-image-data tag (notmuch-tag-star-icon))))
138   "Custom formats for individual tags.
139
140 This is an association list that maps from tag name regexps to
141 lists of formatting expressions.  The first entry whose car
142 regexp-matches a tag will be used to format that tag.  The regexp
143 is implicitly anchored, so to match a literal tag name, just use
144 that tag name (if it contains special regexp characters like
145 \".\" or \"*\", these have to be escaped).  The cdr of the
146 matching entry gives a list of Elisp expressions that modify the
147 tag.  If the list is empty, the tag will simply be hidden.
148 Otherwise, each expression will be evaluated in order: for the
149 first expression, the variable `tag' will be bound to the tag
150 name; for each later expression, the variable `tag' will be bound
151 to the result of the previous expression.  In this way, each
152 expression can build on the formatting performed by the previous
153 expression.  The result of the last expression will displayed in
154 place of the tag.
155
156 For example, to replace a tag with another string, simply use
157 that string as a formatting expression.  To change the foreground
158 of a tag to red, use the expression
159   (propertize tag 'face '(:foreground \"red\"))
160
161 See also `notmuch-tag-format-image', which can help replace tags
162 with images."
163   :group 'notmuch-search
164   :group 'notmuch-show
165   :group 'notmuch-faces
166   :type 'notmuch-tag-format-type)
167
168 (defface notmuch-tag-deleted
169   '((((class color) (supports :strike-through "red")) :strike-through "red")
170     (t :inverse-video t))
171   "Face used to display deleted tags.
172
173 Used in the default value of `notmuch-tag-deleted-formats`."
174   :group 'notmuch-faces)
175
176 (defcustom notmuch-tag-deleted-formats
177   '(("unread" (notmuch-apply-face bare-tag `notmuch-tag-deleted))
178     (".*" (notmuch-apply-face tag `notmuch-tag-deleted)))
179   "Custom formats for tags when deleted.
180
181 For deleted tags the formats in `notmuch-tag-formats` are applied
182 first and then these formats are applied on top; that is `tag'
183 passed to the function is the tag with all these previous
184 formattings applied. The formatted can access the original
185 unformatted tag as `bare-tag'.
186
187 By default this shows deleted tags with strike-through in red,
188 unless strike-through is not available (e.g., emacs is running in
189 a terminal) in which case it uses inverse video. To hide deleted
190 tags completely set this to
191   '((\".*\" nil))
192
193 See `notmuch-tag-formats' for full documentation."
194   :group 'notmuch-show
195   :group 'notmuch-faces
196   :type 'notmuch-tag-format-type)
197
198 (defface notmuch-tag-added
199   '((t :underline "green"))
200   "Default face used for added tags.
201
202 Used in the default value for `notmuch-tag-added-formats`."
203   :group 'notmuch-faces)
204
205 (defcustom notmuch-tag-added-formats
206   '((".*" (notmuch-apply-face tag 'notmuch-tag-added)))
207   "Custom formats for tags when added.
208
209 For added tags the formats in `notmuch-tag-formats` are applied
210 first and then these formats are applied on top.
211
212 To disable special formatting of added tags, set this variable to
213 nil.
214
215 See `notmuch-tag-formats' for full documentation."
216   :group 'notmuch-show
217   :group 'notmuch-faces
218   :type 'notmuch-tag-format-type)
219
220 (defun notmuch-tag-format-image-data (tag data)
221   "Replace TAG with image DATA, if available.
222
223 This function returns a propertized string that will display image
224 DATA in place of TAG.This is designed for use in
225 `notmuch-tag-formats'.
226
227 DATA is the content of an SVG picture (e.g., as returned by
228 `notmuch-tag-star-icon')."
229   (propertize tag 'display
230               `(image :type svg
231                       :data ,data
232                       :ascent center
233                       :mask heuristic)))
234
235 (defun notmuch-tag-star-icon ()
236   "Return SVG data representing a star icon.
237 This can be used with `notmuch-tag-format-image-data'."
238   "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>
239 <svg version=\"1.1\" width=\"16\" height=\"16\">
240   <g transform=\"translate(-242.81601,-315.59635)\">
241     <path
242        d=\"m 290.25762,334.31206 -17.64143,-11.77975 -19.70508,7.85447 5.75171,-20.41814 -13.55925,-16.31348 21.19618,-0.83936 11.325,-17.93675 7.34825,19.89939 20.55849,5.22795 -16.65471,13.13786 z\"
243        transform=\"matrix(0.2484147,-0.02623394,0.02623394,0.2484147,174.63605,255.37691)\"
244        style=\"fill:#ffff00;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1\" />
245   </g>
246 </svg>")
247
248 (defun notmuch-tag-star-empty-icon ()
249   "Return SVG data representing an empty star icon.
250 This can be used with `notmuch-tag-format-image-data'."
251   "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>
252 <svg version=\"1.1\" width=\"16\" height=\"16\">
253   <g transform=\"translate(-242.81601,-315.59635)\">
254     <path
255        d=\"m 290.25762,334.31206 -17.64143,-11.77975 -19.70508,7.85447 5.75171,-20.41814 -13.55925,-16.31348 21.19618,-0.83936 11.325,-17.93675 7.34825,19.89939 20.55849,5.22795 -16.65471,13.13786 z\"
256        transform=\"matrix(0.2484147,-0.02623394,0.02623394,0.2484147,174.63605,255.37691)\"
257        style=\"fill:#d6d6d1;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1\" />
258   </g>
259 </svg>")
260
261 (defun notmuch-tag-tag-icon ()
262   "Return SVG data representing a tag icon.
263 This can be used with `notmuch-tag-format-image-data'."
264   "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>
265 <svg version=\"1.1\" width=\"16\" height=\"16\">
266   <g transform=\"translate(0,-1036.3622)\">
267     <path
268        d=\"m 0.44642857,1040.9336 12.50000043,0 2.700893,3.6161 -2.700893,3.616 -12.50000043,0 z\"
269        style=\"fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.25;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1\" />
270   </g>
271 </svg>")
272
273 (defvar notmuch-tag--format-cache (make-hash-table :test 'equal)
274   "Cache of tag format lookup.  Internal to `notmuch-tag-format-tag'.")
275
276 (defun notmuch-tag-clear-cache ()
277   "Clear the internal cache of tag formats."
278   (clrhash notmuch-tag--format-cache))
279
280 (defun notmuch-tag--get-formats (tag format-alist)
281   "Find the first item whose car regexp-matches TAG."
282   (save-match-data
283     ;; Don't use assoc-default since there's no way to distinguish a
284     ;; missing key from a present key with a null cdr.
285     (cl-assoc tag format-alist
286               :test (lambda (tag key)
287                       (and (eq (string-match key tag) 0)
288                            (= (match-end 0) (length tag)))))))
289
290 (defun notmuch-tag--do-format (tag formatted-tag formats)
291   "Apply a tag-formats entry to TAG."
292   (cond ((null formats)         ;; - Tag not in `formats',
293          formatted-tag)         ;;   the format is the tag itself.
294         ((null (cdr formats))   ;; - Tag was deliberately hidden,
295          nil)                   ;;   no format must be returned
296         (t
297          ;; Tag was found and has formats, we must apply all the
298          ;; formats.  TAG may be null so treat that as a special case.
299          (let ((bare-tag tag)
300                (tag (copy-sequence (or formatted-tag ""))))
301            (dolist (format (cdr formats))
302              (setq tag (eval format)))
303            (if (and (null formatted-tag) (equal tag ""))
304                nil
305              tag)))))
306
307 (defun notmuch-tag-format-tag (tags orig-tags tag)
308   "Format TAG according to `notmuch-tag-formats'.
309
310 TAGS and ORIG-TAGS are lists of the current tags and the original
311 tags; tags which have been deleted (i.e., are in ORIG-TAGS but
312 are not in TAGS) are shown using formats from
313 `notmuch-tag-deleted-formats'; tags which have been added (i.e.,
314 are in TAGS but are not in ORIG-TAGS) are shown using formats
315 from `notmuch-tag-added-formats' and tags which have not been
316 changed (the normal case) are shown using formats from
317 `notmuch-tag-formats'."
318   (let* ((tag-state (cond ((not (member tag tags)) 'deleted)
319                           ((not (member tag orig-tags)) 'added)))
320          (formatted-tag (gethash (cons tag tag-state)
321                                  notmuch-tag--format-cache
322                                  'missing)))
323     (when (eq formatted-tag 'missing)
324       (let ((base (notmuch-tag--get-formats tag notmuch-tag-formats))
325             (over (cl-case tag-state
326                     (deleted (notmuch-tag--get-formats
327                               tag notmuch-tag-deleted-formats))
328                     (added (notmuch-tag--get-formats
329                             tag notmuch-tag-added-formats))
330                     (otherwise nil))))
331         (setq formatted-tag (notmuch-tag--do-format tag tag base))
332         (setq formatted-tag (notmuch-tag--do-format tag formatted-tag over))
333         (puthash (cons tag tag-state) formatted-tag notmuch-tag--format-cache)))
334     formatted-tag))
335
336 (defun notmuch-tag-format-tags (tags orig-tags &optional face)
337   "Return a string representing formatted TAGS."
338   (let ((face (or face 'notmuch-tag-face))
339         (all-tags (sort (delete-dups (append tags orig-tags nil)) #'string<)))
340     (notmuch-apply-face
341      (mapconcat #'identity
342                 ;; nil indicated that the tag was deliberately hidden
343                 (delq nil (mapcar (apply-partially #'notmuch-tag-format-tag
344                                                    tags orig-tags)
345                                   all-tags))
346                 " ")
347      face
348      t)))
349
350 (defcustom notmuch-before-tag-hook nil
351   "Hooks that are run before tags of a message are modified.
352
353 'tag-changes' will contain the tags that are about to be added or removed as
354 a list of strings of the form \"+TAG\" or \"-TAG\".
355 'query' will be a string containing the search query that determines
356 the messages that are about to be tagged."
357   :type 'hook
358   :options '(notmuch-hl-line-mode)
359   :group 'notmuch-hooks)
360
361 (defcustom notmuch-after-tag-hook nil
362   "Hooks that are run after tags of a message are modified.
363
364 'tag-changes' will contain the tags that were added or removed as
365 a list of strings of the form \"+TAG\" or \"-TAG\".
366 'query' will be a string containing the search query that determines
367 the messages that were tagged."
368   :type 'hook
369   :options '(notmuch-hl-line-mode)
370   :group 'notmuch-hooks)
371
372 (defvar notmuch-select-tag-history nil
373   "Variable to store minibuffer history for
374 `notmuch-select-tag-with-completion' function.")
375
376 (defvar notmuch-read-tag-changes-history nil
377   "Variable to store minibuffer history for
378 `notmuch-read-tag-changes' function.")
379
380 (defun notmuch-tag-completions (&rest search-terms)
381   "Return a list of tags for messages matching SEARCH-TERMS.
382
383 Returns all tags if no search terms are given."
384   (unless search-terms
385     (setq search-terms (list "*")))
386   (split-string
387    (with-output-to-string
388      (with-current-buffer standard-output
389        (apply 'call-process notmuch-command nil t
390               nil "search" "--output=tags" "--exclude=false" search-terms)))
391    "\n+" t))
392
393 (defun notmuch-select-tag-with-completion (prompt &rest search-terms)
394   (let ((tag-list (apply #'notmuch-tag-completions search-terms)))
395     (completing-read prompt tag-list nil nil nil 'notmuch-select-tag-history)))
396
397 (defun notmuch-read-tag-changes (current-tags &optional prompt initial-input)
398   "Prompt for tag changes in the minibuffer.
399
400 CURRENT-TAGS is a list of tags that are present on the message or
401 messages to be changed.  These are offered as tag removal
402 completions.  CURRENT-TAGS may contain duplicates.  PROMPT, if
403 non-nil, is the query string to present in the minibuffer.  It
404 defaults to \"Tags\".  INITIAL-INPUT, if non-nil, will be the
405 initial input in the minibuffer."
406   (let* ((all-tag-list (notmuch-tag-completions))
407          (add-tag-list (mapcar (apply-partially 'concat "+") all-tag-list))
408          (remove-tag-list (mapcar (apply-partially 'concat "-") current-tags))
409          (tag-list (append add-tag-list remove-tag-list))
410          (prompt (concat (or prompt "Tags") " (+add -drop): "))
411          (crm-separator " ")
412          ;; By default, space is bound to "complete word" function.
413          ;; Re-bind it to insert a space instead.  Note that <tab>
414          ;; still does the completion.
415          (crm-local-completion-map
416           (let ((map (make-sparse-keymap)))
417             (set-keymap-parent map crm-local-completion-map)
418             (define-key map " " 'self-insert-command)
419             map)))
420     (delete "" (completing-read-multiple
421                 prompt
422                 ;; Append the separator to each completion so when the
423                 ;; user completes a tag they can immediately begin
424                 ;; entering another.  `completing-read-multiple'
425                 ;; ultimately splits the input on crm-separator, so we
426                 ;; don't need to strip this back off (we just need to
427                 ;; delete "empty" entries caused by trailing spaces).
428                 (mapcar (lambda (tag-op) (concat tag-op crm-separator)) tag-list)
429                 nil nil initial-input
430                 'notmuch-read-tag-changes-history))))
431
432 (defun notmuch-update-tags (tags tag-changes)
433   "Return a copy of TAGS with additions and removals from TAG-CHANGES.
434
435 TAG-CHANGES must be a list of tags names, each prefixed with
436 either a \"+\" to indicate the tag should be added to TAGS if not
437 present or a \"-\" to indicate that the tag should be removed
438 from TAGS if present."
439   (let ((result-tags (copy-sequence tags)))
440     (dolist (tag-change tag-changes)
441       (let ((op (string-to-char tag-change))
442             (tag (unless (string= tag-change "") (substring tag-change 1))))
443         (cl-case op
444           (?+ (unless (member tag result-tags)
445                 (push tag result-tags)))
446           (?- (setq result-tags (delete tag result-tags)))
447           (otherwise
448            (error "Changed tag must be of the form `+this_tag' or `-that_tag'")))))
449     (sort result-tags 'string<)))
450
451 (defconst notmuch-tag-argument-limit 1000
452   "Use batch tagging if the tagging query is longer than this.
453
454 This limits the length of arguments passed to the notmuch CLI to
455 avoid system argument length limits and performance problems.")
456
457 (defun notmuch-tag (query tag-changes)
458   "Add/remove tags in TAG-CHANGES to messages matching QUERY.
459
460 QUERY should be a string containing the search-terms.
461 TAG-CHANGES is a list of strings of the form \"+tag\" or
462 \"-tag\" to add or remove tags, respectively.
463
464 Note: Other code should always use this function to alter tags of
465 messages instead of running (notmuch-call-notmuch-process \"tag\" ..)
466 directly, so that hooks specified in notmuch-before-tag-hook and
467 notmuch-after-tag-hook will be run."
468   ;; Perform some validation
469   (mapc (lambda (tag-change)
470           (unless (string-match-p "^[-+]\\S-+$" tag-change)
471             (error "Tag must be of the form `+this_tag' or `-that_tag'")))
472         tag-changes)
473   (unless query
474     (error "Nothing to tag!"))
475   (unless (null tag-changes)
476     (run-hooks 'notmuch-before-tag-hook)
477     (if (<= (length query) notmuch-tag-argument-limit)
478         (apply 'notmuch-call-notmuch-process "tag"
479                (append tag-changes (list "--" query)))
480       ;; Use batch tag mode to avoid argument length limitations
481       (let ((batch-op (concat (mapconcat #'notmuch-hex-encode tag-changes " ")
482                               " -- " query)))
483         (notmuch-call-notmuch-process :stdin-string batch-op "tag" "--batch")))
484     (run-hooks 'notmuch-after-tag-hook)))
485
486 (defun notmuch-tag-change-list (tags &optional reverse)
487   "Convert TAGS into a list of tag changes.
488
489 Add a \"+\" prefix to any tag in TAGS list that doesn't already
490 begin with a \"+\" or a \"-\". If REVERSE is non-nil, replace all
491 \"+\" prefixes with \"-\" and vice versa in the result."
492   (mapcar (lambda (str)
493             (let ((s (if (string-match "^[+-]" str) str (concat "+" str))))
494               (if reverse
495                   (concat (if (= (string-to-char s) ?-) "+" "-")
496                           (substring s 1))
497                 s)))
498           tags))
499
500 (defvar notmuch-tag-jump-reverse-key "k"
501   "The key in tag-jump to switch to the reverse tag changes.")
502
503 (defun notmuch-tag-jump (reverse)
504   "Create a jump menu for tagging operations.
505
506 Creates and displays a jump menu for the tagging operations
507 specified in `notmuch-tagging-keys'. If REVERSE is set then it
508 offers a menu of the reverses of the operations specified in
509 `notmuch-tagging-keys'; i.e. each `+tag` is replaced by `-tag`
510 and vice versa."
511   ;; In principle this function is simple, but it has to deal with
512   ;; lots of cases: different modes (search/show/tree), whether a name
513   ;; is specified, whether the tagging operations is a list of
514   ;; tag-ops, or a symbol that evaluates to such a list, and whether
515   ;; REVERSE is specified.
516   (interactive "P")
517   (let (action-map)
518     (pcase-dolist (`(,key ,tag ,name) notmuch-tagging-keys)
519       (let* ((tag-function (cl-case major-mode
520                              (notmuch-search-mode #'notmuch-search-tag)
521                              (notmuch-show-mode #'notmuch-show-tag)
522                              (notmuch-tree-mode #'notmuch-tree-tag)))
523              (tag (if (symbolp tag)
524                       (symbol-value tag)
525                     tag))
526              (tag-change (if reverse
527                              (notmuch-tag-change-list tag 't)
528                            tag))
529              (name (or (and (not (string= name ""))
530                             name)
531                        (and (symbolp name)
532                             (symbol-name name))))
533              (name-string (if name
534                               (if reverse
535                                   (concat "Reverse " name)
536                                 name)
537                             (mapconcat #'identity tag-change " "))))
538         (push (list key name-string
539                     `(lambda () (,tag-function ',tag-change)))
540               action-map)))
541     (push (list notmuch-tag-jump-reverse-key
542                 (if reverse
543                     "Forward tag changes "
544                   "Reverse tag changes")
545                 (apply-partially 'notmuch-tag-jump (not reverse)))
546           action-map)
547     (setq action-map (nreverse action-map))
548     (notmuch-jump action-map "Tag: ")))
549
550 ;;
551
552 (provide 'notmuch-tag)