X-Git-Url: https://git.notmuchmail.org/git?p=notmuch-wiki;a=blobdiff_plain;f=emacstips.mdwn;h=3bf06fd7f5939dc5750f78a10013f04b2f6e6436;hp=dade16927418fc64d67c5ed6036db5c6bf95a25e;hb=8bf95525c058d8265be9357f6bdeeed2a7b331bd;hpb=bd9116b218d3e1b6f796e03fb5113b3c6187d985

diff --git a/emacstips.mdwn b/emacstips.mdwn
index dade169..3bf06fd 100644
--- a/emacstips.mdwn
+++ b/emacstips.mdwn
@@ -1,114 +1,11 @@
 [[!img notmuch-logo.png alt="Notmuch logo" class="left"]]
-# Tips and Tricks for using notmuch with Emacs
+# Tips and Tricks for using Notmuch with Emacs
 
-One of the more popular notmuch message reading clients is
-**notmuch.el**, an [emacs](http://www.gnu.org/software/emacs/) major
-mode for interacting with notmuch.  It is included in the notmuch
-package (notmuch-emacs in Debian).  This page goes over some usage
-tips for using notmuch with Emacs.
+Here are some tips and tricks for using Notmuch with Emacs. See the [[Notmuch
+Emacs Interface|notmuch-emacs]] page for basics.
 
 [[!toc levels=2]]
 
-## Setup
-
-Have a look at the [Howto](http://notmuchmail.org/howto/) for
-prerequisites.  Be sure you have done the general setup using the
-notmuch cli command!
-
-To use the Notmuch emacs mode, first add the following line to your
-`.emacs` rc file:
-
-        (autoload 'notmuch "notmuch" "notmuch mail" t)
-
-or if you always want to load notmuch when you start emacs:
-
-        (require 'notmuch)
-
-Then, either run "emacs -f notmuch", or execute the command `M-x
-notmuch` from within a running emacs.
-
-### <span id="notmuch_init_file"> Notmuch Emacs configuration file: </span>
-
-(Since Notmuch 0.18)
-
-After notmuch is loaded `notmuch-init-file` (typically
- `~/.emacs.d/notmuch-config.el`) is checked out. If such file exists
-it is loaded. Most emacs lisp based configuration not suitable via
-customization can be put there instead of `~/.emacs`.
-
-## Navigating & reading mails
-
-When first starting notmuch in emacs, you will be presented with the
-notmuch "hello" page.  If it exits with an error after writing
-"Welcome to notmutch. You have" you need to do the basic notmuch setup
-first (see above).
-From here you can do searches, see lists of recent
-searches, saved searches, message tags, help information, etc.
-
-Executing a search will open a new buffer in `notmuch-search-mode`
-displaying the search results.  Each line in the search results
-represents a message thread.  Hitting the '?' key will show help for
-this mode.
-
-In general, the 'q' will kill the current notmuch buffer and return
-you to the previous buffer (sort of like a 'pop').
-
-In search mode, navigating to a thread and hitting return will then
-open a new buffer in `notmuch-show-mode`, which will show the actual
-message contents of the thread.
-
-## Sending mail
-
-In any notmuch mode, you can start a new message by hitting the 'm'
-key.  To reply to a message or thread, just hit the 'r' key.
-
-When composing new messages, you will be entered in emacs's
-`message-mode`, which is a powerful mode for composing and sending
-messages.  When in message mode, you can type `C-c ?` for help.
-
-If you would like to use address autocompletion when composing
-messages, see [address completion](#address_completion).
-
-When you are ready to send a message, type `C-c C-c`. By default
-message mode will use your sendmail command to send mail, so make sure
-that works. One annoying standard configuration of message mode is
-that it will hide the sent mail in your emacs frame stack, but it will
-not close it. If you type several mails in an emacs session they will
-accumulate and make switching between buffers more annoying. You can
-avoid that behavior by adding `(setq message-kill-buffer-on-exit t)`
-in your `.emacs` file
-(or doing `M-x customize-variable<RET>message-kill-buffer-on-exit<RET>`)
-which will really close the mail window after sending it.
-
-## Attaching files
-
-Using the `M-x mml-attach-file` command, you can attach any file to be
-sent with your mail. By default this command is bound to the menu item
-*Attachments--Attach File* with the key binding `C-c C-a`. The
-variable `mml-dnd-attach-options` (`M-x
-customize-variable<RET>mml-dnd-attach-options<RET>`) can be set to
-allow the prompting for various attachment options (such as
-inline/attachment) if you want to do that.
-
-For those who prefer a more graphical interface, you can also simply
-drag and drop files from a file manager into a mail composition window
-to have them attached. In Ubuntu this works without any modifications
-if files are dragged from the file manager.
-
-And for those who prefer working from command line, the following
-script opens new emacs window with empty message and attaches files
-mentioned as script arguments. (Note: The script expects that you have
-`(server-start)` in your `.emacs` file.)
-
-        #!/bin/sh
-        attach_cmds=""
-        while [ $# -gt 0 ]; do
-            fullpath=$(readlink --canonicalize "$1")
-            attach_cmds="$attach_cmds (mml-attach-file \"$fullpath\")"
-            shift
-        done
-        emacsclient -a '' -c -e "(progn (compose-mail) $attach_cmds)"
-
 ## Issues with Emacs 24
 
 If notmuch-show-mode behaves badly for you in emacs 24.x try adding one of
@@ -121,9 +18,23 @@ or
 
 to your .emacs file.
 
------
+## Controlling external handlers for attachments
+
+You can choose e.g. which pdf viewer to invoke from notmuch-show mode by
+adding a .mailcap file in your home directory. Here is an example:
 
-# Advanced tips and tweaks
+    application/pdf; /usr/bin/mupdf %s; test=test "$DISPLAY" != ""; description=Portable Document Format; nametemplate=%s.pdf
+    application/x-pdf; /usr/bin/mupdf %s; test=test "$DISPLAY" != ""; description=Portable Document Format; nametemplate=%s.pdf
+
+## Overwriting the sender address
+
+If you want to always use the same sender address, then the following
+defadvice can help you.
+
+       (defadvice notmuch-mua-reply (around notmuch-fix-sender)
+         (let ((sender "Max Monster <max.monster@example.com>"))
+           ad-do-it))
+       (ad-activate 'notmuch-mua-reply)
 
 ## Initial cursor position in notmuch 0.15 hello window
 
@@ -245,11 +156,15 @@ reply-to-all. Here's how to swap the reply to sender/all bindings in show mode:
         (define-key notmuch-show-mode-map "r" 'notmuch-show-reply)
         (define-key notmuch-show-mode-map "R" 'notmuch-show-reply-sender)
 
-And in search mode:
+In search mode:
 
         (define-key notmuch-search-mode-map "r" 'notmuch-search-reply-to-thread)
         (define-key notmuch-search-mode-map "R" 'notmuch-search-reply-to-thread-sender)
 
+And in tree mode:
+
+        (define-key notmuch-tree-mode-map "r" (notmuch-tree-close-message-pane-and #'notmuch-show-reply))
+        (define-key notmuch-tree-mode-map "R" (notmuch-tree-close-message-pane-and #'notmuch-show-reply-sender))
 
 ## How to do FCC/BCC...
 
@@ -307,7 +222,7 @@ displaying the count for the saved-search. For example
         (setq notmuch-saved-searches '((:name "inbox"
                                         :query "tag:inbox"
                                         :count-query "tag:inbox and tag:unread"
-                                        :sort-order 'oldest-first)))
+                                        :sort-order oldest-first)))
 
 specifies a single saved search for inbox, but the number displayed by
 the search will be the number of unread messages in the inbox, and the
@@ -326,51 +241,28 @@ useful to you.
 
 ## Viewing HTML messages with an external viewer
 
-The emacs client can display an HTML message inline using either the
-`html2text` library or some text browser, like w3m or lynx. This is
-controlled by the `mm-text-html-renderer` variable.
+The Emacs client can generally display HTML messages inline using one of the
+supported HTML renderers. This is controlled by the `mm-text-html-renderer`
+variable.
 
-The first option is theorically better, because it can generate
-strings formatted for emacs and do whatever you want, e.g., substitute
-text inside &lt;b&gt; tags for bold text in the buffer. The library, however
-is still in a very early development phase and cannot yet process
-properly many elements, like tables and <style> directives, and even
-the generated text is often poorly formatted.
+Sometimes it may be necessary to display the message, or a single MIME part, in
+an external browser. This can be done by `(notmuch-show-view-part)`, bound to
+`. v` by default.
 
-Among the available browsers, w3m seems to do a better job converting
-the html, and if you have the w3m emacs package, you can use it,
-instead of the w3m-standalone, and thus preserve the text formatting.
+This command will try to view the message part the point is on with an
+external viewer. The mime-type of the part will determine what viewer
+will be used. Typically a 'text/html' part will be send to your
+browser. 
 
-But if the rendering fails for one reason or another, or if you really
-need to see the graphical presentation of the HTML message, it can be
-useful to display the message in an external viewer, such as a web
-browser. Here's a little script that Keith Packard wrote, which he
-calls `view-html`:
+The configuration for this is kept in so called `mailcap`
+files. (typically the file is `~/.mailcap` or `/etc/mailcap`) If the
+wrong viewer is started or something else goes wrong, there's a good
+chance something needs to be adapted in the mailcap configuration.
+
+For Example: The `copiousoutput` setting in mailcap files needs to be
+removed for some mime-types to prevent immediate removal of tempory
+files so the configured viewer can access them.
 
-        #!/bin/sh
-        dir=`mktemp -d`
-        trap "rm -r $dir" 0
-        cat "$@" > "$dir"/msg
-        if munpack -C "$dir" -t < "$dir"/msg 2>&1 | grep 'Did not find'; then
-            sed -n '/[Hh][Tt][Mm][Ll]/,$p' "$dir"/msg > $dir/part1.html
-            rm "$dir"/msg
-        fi
-        for i in "$dir"/part*; do
-            if grep -q -i -e '<html>' -e 'text/html' "$i"; then
-                iceweasel "$i" &
-                sleep 3
-                exit 0
-            fi
-        done
-
-Save that script somewhere in your `${PATH}`, make it executable,
-and change the invocation of `iceweasel` to any other HTML viewer if
-necessary. Then within the emacs client, press '|' to pipe the
-current message, then type "view-html".
-
-Keith mentions the following caveat, "Note that if iceweasel isn't
-already running, it seems to shut down when the script exits. I
-don't know why."
 
 ## msmtp, message mode and multiple accounts
 
@@ -401,17 +293,72 @@ With that in place, you need a `.msmtprc` with the accounts configured
 for the domains you want to send out using specific SMTP servers and
 the rest will go to the default account.
 
-If you have a hard time getting the above to work for you, as I did,
-it's also possible to add a message-send-mail-hook in your .emacs to
-send the from header explicitly as an argument to msmtp as described
-[here](http://www.emacswiki.org/cgi-bin/wiki/GnusMSMTP#toc2) on the
-emacswiki.
+## sending mail using smtpmail
+
+<!-- By default message mode will use the system `sendmail` command to send
+mail. However, on a typical desktop machine there may not be local SMTP
+daemon running (nor it is configured to send mail outside of the system). -->
+
+If setting up local `sendmail` or `msmtp` is not feasible or desirable,
+the Emacs `smtpmail` package can be used to send email by talking to remote
+SMTP server via TCP connection. It is pretty easy to configure:
+
+1. Emacs variable `message-send-mail-function` has not been set
+
+   Initially, Emacs variable `message-send-mail-function` has value of
+   `sendmail-query-once`. When (notmuch) message mode is about to send email,
+   `sendmail-query-once` will ask how emacs should send email. Typing `smtp`
+   will configure `smtpmail` and Emacs may prompt for SMTP settings.
+
+1. `M-x customize-group RET smtpmail`
+
+   As a minimum, 'Smtpmail Smtp Server' needs to be set.
+
+   After doing that, continue with `M-x load-library RET message` and
+   `M-x customize-variable RET message-send-mail-function`.
+   In the customization buffer select `message-smtpmail-send-it`.
+
+1. Set some variables in .emacs or in [notmuch init file](/notmuch-emacs#notmuch_init_file)
+
+        (setq smtpmail-smtp-server "smtp.server.tld" ;; <-- edit this !!!
+        ;;    smtpmail-smtp-service 25 ;; 25 is default -- uncomment and edit if needed
+        ;;    smtpmail-stream-type 'starttls
+        ;;    smtpmail-debug-info t
+        ;;    smtpmail-debug-verb t
+              message-send-mail-function 'message-smtpmail-send-it)
+
+Note that emacs 24 or newer is required for `smtpmail-stream-type`
+(and smtp authentication) to be effective.
+
+More information for smtpmail is available:
+
+* In Emacs: `M-x info-display-manual smtpmail`
+* [EmacsWiki Page](http://www.emacswiki.org/emacs/SendingMail)
 
 
 ## <span id="address_completion">Address completion when composing</span>
 
 There are currently three solutions to this:
 
+### notmuch address
+
+Starting with Notmuch 0.21, there is a builtin command to perform
+autocompletion directly within Notmuch. Starting with 0.22, it is
+configured by default, so if you have previously configured another
+completion mechanism, you may want to try out the new internal
+method. Use `M-x customize-variable RET notmuch-address-command` and
+reset the value to "internal address completion" (`'internal` in
+lisp).
+
+If you are not yet running 0.22, you can still use it by adding a
+wrapper around the command called, say, `notmuch-address`:
+
+    #!/bin/sh
+    exec notmuch address from:"$*"
+
+Then you can set the `notmuch-address-command` to `notmuch-address`
+(if it is in your `$PATH` of course, otherwise use an absolute path).
+
 ### bbdb
 
 [bbdb](http://bbdb.sourceforge.net) is a contact database for emacs
@@ -429,9 +376,14 @@ available:
     http://commonmeasure.org/~jkr/git/notmuch_addresses.git`) (slower, but
     no compilation required so good for testing the setup)
 
+  * The C-based [notmuch-addrlookup](https://github.com/aperezdc/notmuch-addrlookup-c) by [Adrian Perez](http://perezdecastro.org/), which is faster but needs to be compiled.
+
+        git clone https://github.com/aperezdc/notmuch-addrlookup-c
+        cd notmuch-addrlookup-c
+        make
+
   * The vala-based
-    [addrlookup](http://github.com/spaetz/vala-notmuch) (faster, but
-    needs compiling).  The addrlookup binary needs to be compiled.
+    [addrlookup](http://github.com/spaetz/vala-notmuch) The addrlookup binary needs to be compiled.
     Grab
     `http://github.com/spaetz/vala-notmuch/raw/static-sources/src/addrlookup.c`
     and build it with:
@@ -439,7 +391,7 @@ available:
             cc -o addrlookup addrlookup.c `pkg-config --cflags --libs gobject-2.0` -lnotmuch
 
   * Shell/fgrep/perl combination [nottoomuch-addresses.sh](https://github.com/domo141/nottoomuch/blob/master/nottoomuch-addresses.rst).
-    This tools maintains it's own address "database" gathered from email
+    This tools maintains its own address "database" gathered from email
     files notmuch knows and search from that "database" is done by `fgrep(1)`.
 
   * python/sqlite combination [notmuch-abook](https://github.com/guyzmo/notmuch-abook/)
@@ -447,7 +399,7 @@ available:
     from notmuch.  It also includes a vim plugin.
 
 You can perform tab-completion using any of these programs.
-Just add the following to your [[notmuch init file|#notmuch_init_file]]:
+Just add the following to your [notmuch init file](/notmuch-emacs#notmuch_init_file):
 
         (require 'notmuch-address)
         (setq notmuch-address-command "/path/to/address_fetching_program")
@@ -478,24 +430,33 @@ Enter the cloned repository and create a build directory:
         cd build
         cmake ..; make;
 
-You will find the akonadimailsearch binary in the build/src directory.
-Create a ~/bin/akonadimailsearch.sh file with the following content and make it executable:
-(Adjust the path for the akonadimailsearch binary.)
-
-        #!/bin/sh
-        akonadimailsearch "$@" 2>/dev/null
+You will find the akonadimailsearch binary in the build/src directory. Copy it to ~/bin .
 
-As described above, you can now add the following settings to your
-[[notmuch init file|#notmuch_init_file]]:
+You can now add the following settings to your
+[notmuch init file](/notmuch-emacs#notmuch_init_file):
 
         (require 'notmuch-address)
-        (setq notmuch-address-command "~/bin/akonadimailsearch.sh")
+        (setq notmuch-address-command "~/bin/akonadimailsearch")
         (notmuch-address-message-insinuate)
 
+### Completion selection with helm
+
+An address query might return multiple possible matches from which you
+will have to select one. To ease this task, several different
+frameworks in emacs support completion selection. One of them is
+[helm](https://github.com/emacs-helm/helm). The following snippet
+improves the out-of-the-box support for helm in notmuch as it enables
+the required-match option and also does not ignore the first returned
+address.
+
+        (setq notmuch-address-selection-function
+          (lambda (prompt collection initial-input)
+            (completing-read prompt (cons initial-input collection) nil t nil 'notmuch-address-history)))
+
 
 ## How to sign/encrypt messages with gpg
 
-Messages can by signed using gpg by invoking
+Messages can be signed using gpg by invoking
 `M-x mml-secure-sign-pgpmime` (or `M-x mml-secure-encrypt-pgpmime`).
 These functions are available via the standard `message-mode` keybindings
 `C-c C-m s p` and `C-c C-m c p`. To sign outgoing mail by default, use the
@@ -513,6 +474,42 @@ Alternatively, you may prefer to use `mml-secure-message-sign-pgpmime` instead
 of `mml-secure-sign-pgpmime` to sign the whole message instead of just one
 part.
 
+If you want to automatically encrypt outgoing messages if the keyring
+contains a public key for every recipient, you can add something like
+that to your `.emacs` file:
+
+    (defun message-recipients ()
+      "Return a list of all recipients in the message, looking at TO, CC and BCC.
+
+    Each recipient is in the format of `mail-extract-address-components'."
+      (mapcan (lambda (header)
+                (let ((header-value (message-fetch-field header)))
+                  (and
+                   header-value
+                   (mail-extract-address-components header-value t))))
+              '("To" "Cc" "Bcc")))
+
+    (defun message-all-epg-keys-available-p ()
+      "Return non-nil if the pgp keyring has a public key for each recipient."
+      (require 'epa)
+      (let ((context (epg-make-context epa-protocol)))
+        (catch 'break
+          (dolist (recipient (message-recipients))
+            (let ((recipient-email (cadr recipient)))
+              (when (and recipient-email (not (epg-list-keys context recipient-email)))
+                (throw 'break nil))))
+          t)))
+
+    (defun message-sign-encrypt-if-all-keys-available ()
+      "Add MML tag to encrypt message when there is a key for each recipient.
+
+    Consider adding this function to `message-send-hook' to
+    systematically send encrypted emails when possible."
+      (when (message-all-epg-keys-available-p)
+        (mml-secure-message-sign-encrypt)))
+
+    (add-hook 'message-send-hook #'message-sign-encrypt-if-all-keys-available
+
 ### Troubleshooting message-mode gpg support
 
 - If you have trouble with expired subkeys, you may have encountered
@@ -521,6 +518,26 @@ part.
   installed, it will shadow the fixed version of easypg included with
   emacs.
 
+- If you wish `mml-secure-encrypt` to encrypt also for the sender, then
+  `M-x customize-variable mml2015-encrypt-to-self` might suit your need.
+
+## Reading and verifying encrypted and signed messages
+
+Encrypted and signed mime messages can be read and verified with:
+
+        (setq notmuch-crypto-process-mime t)
+
+Decrypting inline pgp messages can be done by selecting an the inline pgp area
+and using:
+
+        M-x epa-decrypt-region RET
+
+Verifying of inline pgp messages is not supported directly ([reasons
+here](https://dkg.fifthhorseman.net/notes/inline-pgp-harmful/)). You can still
+verify a part using
+
+        M-x notmuch-show-pipe-part RET gpg --verify RET
+
 ## Multiple identities using gnus-alias
 
 [gnus-alias](http://www.emacswiki.org/emacs/GnusAlias) allows you to
@@ -588,9 +605,20 @@ The last two do the same thing.
 
 See also the **Usage:** section in `gnus-alias.el`.
 
+## Multiple identities (and more) with message-templ
+
+Another option for multiple identities is
+[message-templ](http://pivot.cs.unb.ca/git?p=message-templ.git;a=summary)
+(also a available in marmalade).  This provides roughly the same
+facilities as wanderlust's template facility.
+
+See
+[example.emacs.el](http://pivot.cs.unb.ca/git?p=message-templ.git;a=blob;f=example.emacs.el;hb=HEAD)
+for some simple examples of usage.
+
 ## Resending (or bouncing) messages
 
-Add the following to your [[notmuch init file|#notmuch_init_file]] to be able
+Add the following to your [notmuch init file](/notmuch-emacs#notmuch_init_file) to be able
 to resend the current message in show mode.
 
         (define-key notmuch-show-mode-map "b"
@@ -602,7 +630,7 @@ to resend the current message in show mode.
 
 ## `notmuch-hello` refresh status message
 
-Add the following to your [[notmuch init file|#notmuch_init_file]] to get a
+Add the following to your [notmuch init file](/notmuch-emacs#notmuch_init_file) to get a
 status message about the change in the number of messages in the mail store
 when refreshing the `notmuch-hello` buffer.
 
@@ -632,7 +660,7 @@ when refreshing the `notmuch-hello` buffer.
 
 Mailman mailing list software rewrites and rewraps long message subjects in
 a way that causes TABs to appear in the middle of the subject and header
-lines. Add this to your [[notmuch init file|#notmuch_init_file]] to replace
+lines. Add this to your [notmuch init file](/notmuch-emacs#notmuch_init_file) to replace
 tabs with spaces in subject lines:
 
         (defun notmuch-show-subject-tabs-to-spaces ()
@@ -661,7 +689,7 @@ I like to have an inbox saved search, but only show unread messages when they
 view a thread. This takes two steps:
 
 1. Apply
-[this patch from Mark Walters](http://notmuchmail.org/pipermail/notmuch/2012/010817.html)
+[this patch from Mark Walters](https://notmuchmail.org/pipermail/notmuch/2012/010817.html)
 to add the `notmuch-show-filter-thread` function.
 1. Add the following hook to your emacs configuration:
 
@@ -713,11 +741,18 @@ but as a contrib file, so you might have to work a bit to load it.
 
 In Debian and derivatives,
 
-	(add-to-list 'load-path "/usr/share/org-mode/lisp")
+    (add-to-list 'load-path "/usr/share/org-mode/lisp")
+
+In NixOS, using `emacsWithPackages (epkgs: [ epkgs.orgPackages.org-plus-contrib ])`,
+
+    (loop for p in load-path
+          do (if (file-accessible-directory-p p)
+                 (let ((m (directory-files-recursively p "^org-notmuch.el$")))
+                      (if m (add-to-list 'load-path (file-name-directory (car m)))))))
 
 Then
 
-	(require 'org-notmuch)
+    (require 'org-notmuch)
 
 In general it is nice to have a key for org-links (not just for notmuch). For example
 
@@ -733,22 +768,99 @@ refine, next hunk etc all work.
       "View the the current message as a patch."
       (interactive)
       (let* ((id (notmuch-show-get-message-id))
+             (msg (notmuch-show-get-message-properties))
+             (part (notmuch-show-get-part-properties))
              (subject (concat "Subject: " (notmuch-show-get-subject) "\n"))
              (diff-default-read-only t)
              (buf (get-buffer-create (concat "*notmuch-patch-" id "*")))
              (map (make-sparse-keymap)))
-        (define-key map "q" 'notmuch-kill-this-buffer)
+        (define-key map "q" 'notmuch-bury-or-kill-this-buffer)
         (switch-to-buffer buf)
         (let ((inhibit-read-only t))
           (erase-buffer)
           (insert subject)
-          (insert (notmuch-get-bodypart-internal id 1 nil)))
+          (insert (notmuch-get-bodypart-text msg part nil)))
         (set-buffer-modified-p nil)
         (diff-mode)
         (lexical-let ((new-ro-bind (cons 'buffer-read-only map)))
                      (add-to-list 'minor-mode-overriding-map-alist new-ro-bind))
         (goto-char (point-min))))
 
-and then this function needs to bound into the keymap with something like
-
-    (define-key 'notmuch-show-mode-map "D" 'my-notmuch-show-view-as-patch)
+and then this function needs to bound to `. d` in the keymap
+
+    (define-key 'notmuch-show-part-map "d" 'my-notmuch-show-view-as-patch)
+
+## Interfacing with Patchwork
+
+[Patchwork](http://jk.ozlabs.org/projects/patchwork/) is a web-based system for
+tracking patches sent to a mailing list. While the Notmuch project doesn't use
+it, many other open source projects do. Having an easy way to get from a patch
+email in your favorite mail client to the web page of the patch in the Patchwork
+instance is a cool thing to have. Here's how to abuse the notmuch stash feature
+to achieve this. (Don't know stash? See `notmuch-show-stash-mlarchive-link`,
+bound to `c l` in `notmuch-show`.)
+
+The trick needed is turning the email Message-ID into a unique Patchwork ID
+assigned by Patchwork. We'll use the `pwclient` command-line tool to achieve
+this. You'll first need to get that working and configured for the Patchwork
+instance you're using. That part is beyond this tip here; please refer to
+Patchwork documentation.
+
+Check your configuration on the command-line, for example:
+
+    /path/to/pwclient -p <the-project> -n 5 -f "%{id}"
+
+Note that the -f format argument may require a reasonably new version of the
+client. Once you have the above working, you can `M-x customize-variable RET
+notmuch-show-stash-mlarchive-link-alist RET`.
+
+Add a new entry with "Function returning the URL:" set to:
+
+    (lambda (message-id)
+      (concat "http://patchwork.example.com/patch/"
+              (nth 0
+                   (process-lines "/path/to/pwclient" "search"
+                                  "-p" "the-project"
+                                  "-m" (concat "<" message-id ">")
+                                  "-n" "1"
+                                  "-f" "%{id}"))))
+
+Replacing `http://patchwork.example.com/patch/`, `/path/to/pwclient`, and
+`the-project` appropriately. You should now be able to stash the Patchwork URL
+using `c l`.
+
+Going further, if the patch has been committed, you can get the commit hash with
+this:
+
+    (lambda (message-id)
+      (nth 0
+           (process-lines "/path/to/pwclient" "search"
+                          "-p" "the-project"
+                          "-m" (concat "<" message-id ">")
+                          "-n" "1"
+                          "-f" "%{commit_ref}")))
+
+And finally, if the project has a web interface to its source repository, you
+can turn the commit hash into a URL pointing there, for example:
+
+    (lambda (message-id)
+      (concat "http://cgit.example.com/the-project/commit/?id="
+              (nth 0
+                   (process-lines "/path/to/pwclient" "search"
+                                  "-p" "the-project"
+                                  "-m" (concat "<" message-id ">")
+                                  "-n" "1"
+                                  "-f" "%{commit_ref}"))))
+
+## Never forget attachments
+
+Very often we forget to actually attach the file when we send an email
+that's supposed to have an attachment. Did this never happen to you?
+If not, then it will.
+
+There is a hook out there that checks the content of the email for
+keywords and warns you before the email is sent out if there's no
+attachment. This is currently work in progress, but you can already
+add the hook to your `~/.emacs.d/notmuch-config.el` file to test
+it. Details available (and feedback welcome) in the [relevant
+discussion](https://notmuchmail.org/pipermail/notmuch/2018/026414.html).