- (setq notmuch-folders '(("inbox" . "tag:inbox")
- ("unread" . "tag:inbox AND tag:unread")
- ("notmuch" . "tag:inbox AND to:notmuchmail.org")))
-
- Of course, you can have any number of folders, each configured
- with any supported search terms (see "notmuch help search-terms").
-
- Personally, I find it fairly useful to add "not tag:delete" to those
- views as I use that tag to mark messages as deleted and it
- automatically removes them from my standard views. Use whatever
- seems most useful to you.
-
-* **Viewing HTML messages with an external viewer**
-
- The emacs client can often display an HTML message inline, but it
- sometimes fails for one reason or another, (or is perhaps inadequate
- if you really need to see the graphical presentation of the HTML
- message).
-
- In this case, 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:
-
- #!/bin/sh
- dir=3D`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**
-
- As an alternative to running a mail server such as sendmail or
- postfix just to send email, it is possible to use
- [msmtp](http://msmtp.sourceforge.net/). This small application will
- look like /usr/bin/sendmail to a MUA such as emacs message mode, but
- will just forward the email to an external SMTP server. It's fairly
- easy to set up and it support several account for using different
- SMTP servers. The msmtp pages have several examples.
-
- A typical scenario is that you want to use the company SMTP server
- for email coming from your company email address, and your personal
- server for personal email. If msmtp is passed the envelope address
- on the command line (the -f/--from option) it will automatically
- pick the matching account. The only trick here seems to be getting
- emacs to actually pass the envelope from. There are a number of
- overlapping configuration variables that control this, and it's a
- little confusion, but setting these three works for me:
-
- - mail-specify-envelope-from: t
-
- - message-sendmail-envelope-from: header
-
- - mail-envelope-from: header
-
- 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.
-
-* <span id="sync_maildir_flags">**how to sync notmuch tags and maildir
- flags**</span>
-
- There is no built-in support for sunchronizing your notmuch tags
- with your imap maildir flags (seen, replied, trashed, etc). However
- there are currently 2 ways in which you can achieve
- synchronization. In order to sync new notmuch tags to maildir flags,
- there is a python tool called
- [notmuchsync](http://spaetz.github.com/notmuchsync/) that allows
- synchronization in either direction or pruning of deleted files.
-
- The second solution allows for fast maildir flag to notmuch tag
- synchronization (and only in that direction) requires patching the
- notmuch source code. The patch has been posted in this mail
- *id:1267450136-31749-1-git-send-email-Sebastian@SSpaeth.de* and can
- be viewed as a [source diff in this git
- repository](http://github.com/spaetz/notmuch-all-feature/commit/df3b087cefb85e9d16fd17540e348bcb854dd7ee).
-
-* <span id="address_completion">**how to get email address completion**</span>
- There are 2 solutions. Use "bbdb" which allows you to maintain a mail database and gives you mail address completion with the tab key.
-
- Alternatively, you use the notmuch database as a mail address book
- itself. You need a command line tool that outputs likely address
- candidates based on a search string. There is a python tool
- notmuch_address.py (which can be fetched with `git clone
- http://jkr.acm.jhu.edu/git/notmuch_addresses.git`) (slower, but no
- compilation required so good for testing the setup) or the
- vala-based addrlookup (faster, but needs compiling). This is how
- you compile the (3rd party) tool "addrlookup" to give you address
- completion:
-
- - you need the addrlookup binary, first of all. Grab http://github.com/spaetz/vala-notmuch/raw/static-sources/src/addrlookup.c and build it with `cc -o addrlookup addrlookup.c ``pkg-config --cflags --libs gobject-2.0`` -lnotmuch`. That should give you the binary that you can test already.
-
- - EUDC is integrated into emacs and can be used for tab completion
- of email addresses. The code I use is here
- http://gist.github.com/359425. It was announce in [this
- mail](http://mid.gmane.org/87fx3uflkx.fsf@jhu.edu)
- (id:87fx3uflkx.fsf@jhu.edu) which contains links to the git
- repositories which contain the files.
-
-* <span id="insert_user_agent">**how to insert a user agent header**</span>
-
- Sometimes it is good to let the world know which email client you use, so others know which quirks to expect. And it is no shame to let others know that you are way ahead of mail2.0. Notmuch is mail3.0 (at least)!
-
- [This mail](http://mid.gmane.org/87y6gtnkch.fsf@SSpaeth.de) (id:87y6gtnkch.fsf@SSpaeth.de) posted the below code, that -when inserted in your .emacs file- will add a User-Agent header (which is hidden during composing and in notmuch show, but which can be seen when viewing all headers of a mail). The header will looke like this:
- `User-Agent: notmuch version 0.1-92-g3893a9a (Emacs 23.1.1/x86_64-pc-linux-gnu)`
-
-
- ;; set the User-Agent string whenever we invoke message mode
- (add-hook 'message-mode-hook '(lambda()
- ;; check if User-Agent is a required header and set it if not
- (if (not (memq 'User-Agent message-required-mail-headers))
- (setq message-required-mail-headers
- (append message-required-mail-headers '(User-Agent))))
- ;; hide the User-Agent header if not already hidden
- (if (not (memq '"^User-Agent:" message-hidden-headers))
- (setq message-hidden-headers
- (append message-hidden-headers '("^User-Agent:"))))
- ;; create user agent string
- (let ((notmuch-user-agent (concat
- (substring (shell-command-to-string (concat notmuch-command " --version")) 0 -1)
- " (Emacs " emacs-version "/"
- system-configuration ")")))
- (setq message-newsreader notmuch-user-agent))
- ))
-
-
-* <span id="sign_messages_gpg">**how to sign/encrypt my messages with
- gpg**</span>
-
- You can manually sign your messages with gpg by invoking `M-x
- mml-secure-sign-pgpmime` (or `M-x
- mml-secure-encrypt-pgpmime`). These functions are available via the
- convenient (*cough cough*) keybindings `C-c C-m s p` and `C-c C-m c
- p` by default. To sign my outgoing mail by default, I use this hook
- in my .emacs file:
-
- ;;sign messages by default
- (add-hook 'message-setup-hook 'mml-secure-sign-pgpmime)
-
- This inserts the blurb `<#part sign=pgpmime>` into the beginning of
- my mail text body and will be converted into a pgp signature when
- sending (so I can just manually delete that line if I do not want a
- mail to be signed).
\ No newline at end of file
+A typical scenario is that you want to use the company SMTP server
+for email coming from your company email address, and your personal
+server for personal email. If msmtp is passed the envelope address
+on the command line (the -f/--from option) it will automatically
+pick the matching account. The only trick here seems to be getting
+emacs to actually pass the envelope from. There are a number of
+overlapping configuration variables that control this, and it's a
+little confusion, but setting these three works for me:
+
+ - `mail-specify-envelope-from`: `t`
+
+ - `message-sendmail-envelope-from`: `header`
+
+ - `mail-envelope-from`: `header`
+
+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.
+
+## 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
+that works quite nicely together with message mode, including
+address autocompletion.
+
+### notmuch database as an address book
+
+You can also use the notmuch database as a mail address book itself.
+To do this you need a command line tool that outputs likely address
+candidates based on a search string. There are currently four
+available:
+
+ * The python tool `notmuch_address.py` (`git clone
+ 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) The addrlookup binary needs to be compiled.
+ Grab
+ `http://github.com/spaetz/vala-notmuch/raw/static-sources/src/addrlookup.c`
+ and build it with:
+
+ 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 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/)
+ This tools also maintains an address database in sqlite after harvesting
+ 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-emacs#notmuch_init_file):
+
+ (require 'notmuch-address)
+ (setq notmuch-address-command "/path/to/address_fetching_program")
+ (notmuch-address-message-insinuate)
+
+### Google Contacts
+
+[GooBook](http://code.google.com/p/goobook/) is a command-line tool for
+accessing Google Contacts. Install and set it up according to its documentation.
+
+To use GooBook with notmuch, use this wrapper script and set it up like the
+programs above.
+
+ #!/bin/sh
+ goobook query "$*" | sed 's/\(.*\)\t\(.*\)\t.*/\2 \<\1\>/' | sed '/^$/d'
+
+You can add the sender of a message to Google Contacts by piping the message
+(`notmuch-show-pipe-message`) to `goobook add`.
+
+### Akonadi
+
+ git clone https://github.com/mmehnert/akonadimailsearch
+
+Install the development packages for kdepim on your system.
+Enter the cloned repository and create a build directory:
+
+ mkdir build
+ cd build
+ cmake ..; make;
+
+You will find the akonadimailsearch binary in the build/src directory. Copy it to ~/bin .
+
+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")
+ (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 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`.
+
+In Emacs 28 you will be asked whether to sign the message using the
+sender and are offered to remember your choice. In Emacs 27 you will
+get a slightly misleading error and have to manually add the following
+line to you init file. Older Emacsen just do this unconditionally.
+
+ (setq mml-secure-openpgp-sign-with-sender t)
+
+To sign outgoing mail by default, use the `message-setup-hook` in your
+init file:
+
+ ;; Sign messages by default.
+ (add-hook 'message-setup-hook 'mml-secure-sign-pgpmime)
+
+This inserts the required `<#part sign=pgpmime>` into the beginning
+of the mail text body and will be converted into a pgp signature
+when sending (so one can just manually delete that line if signing
+is not required).
+
+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
+ emacs bug #7931. This is fixed in git commit 301ea744c on
+ 2011-02-02. Note that if you have the Debian package easypg
+ 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
+define multiple identities when using `message-mode`. You can specify
+the from address, organization, extra headers (including *Bcc*), extra
+body text, and signature for each identity. Identities are chosen
+based on a set of rules. When you are in message mode, you can switch
+identities using gnus-alias.
+
+### Installation
+
+- put `gnus-alias.el` on your load Emacs-Lisp load path (add new directory
+ to load path by writing `(add-to-list 'load-path "/some/load/path")` into
+ your `.emacs`.
+
+- Add the following to your `.emacs`
+
+ (autoload 'gnus-alias-determine-identity "gnus-alias" "" t)
+ (add-hook 'message-setup-hook 'gnus-alias-determine-identity)
+
+Looking into `gnus-alias.el` gives a bit more information...
+
+### Example Configuration
+
+Here is an example configuration.
+
+ ;; Define two identities, "home" and "work"
+ (setq gnus-alias-identity-alist
+ '(("home"
+ nil ;; Does not refer to any other identity
+ "John Doe <jdoe@example.net>" ;; Sender address
+ nil ;; No organization header
+ nil ;; No extra headers
+ nil ;; No extra body text
+ "~/.signature")
+ ("work"
+ nil
+ "John Doe <john.doe@example.com>"
+ "Example Corp."
+ (("Bcc" . "john.doe@example.com"))
+ nil
+ "~/.signature.work")))
+ ;; Use "home" identity by default
+ (setq gnus-alias-default-identity "home")
+ ;; Define rules to match work identity
+ (setq gnus-alias-identity-rules
+ '(("work" ("any" "john.doe@\\(example\\.com\\|help\\.example.com\\)" both) "work")))
+ ;; Determine identity when message-mode loads
+ (add-hook 'message-setup-hook 'gnus-alias-determine-identity)
+
+When `gnus-alias` has been loaded (using autoload, require, *M-x load-library*
+or *M-x load-file* (load-file takes file path -- therefore it can be used
+without any `.emacs` changes)) the following commands can be used to get(/set)
+more information (some of these have "extensive documentation"):
+
+ M-x describe-variable RET gnus-alias-identity-alist
+ M-x describe-variable RET gnus-alias-identity-rules
+ M-x describe-variable RET gnus-alias-default-identity
+
+ M-x customize-group RET gnus-alias RET
+ or
+ M-x gnus-alias-customize RET
+
+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-emacs#notmuch_init_file) to be able
+to resend the current message in show mode.
+
+ (define-key notmuch-show-mode-map "b"
+ (lambda (&optional address)
+ "Bounce the current message."
+ (interactive "sBounce To: ")
+ (notmuch-show-view-raw-message)
+ (message-resend address)))
+
+## `notmuch-hello` refresh status message
+
+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.
+
+ (defvar notmuch-hello-refresh-count 0)
+
+ (defun notmuch-hello-refresh-status-message ()
+ (unless no-display
+ (let* ((new-count
+ (string-to-number
+ (car (process-lines notmuch-command "count"))))
+ (diff-count (- new-count notmuch-hello-refresh-count)))
+ (cond
+ ((= notmuch-hello-refresh-count 0)
+ (message "You have %s messages."
+ (notmuch-hello-nice-number new-count)))
+ ((> diff-count 0)
+ (message "You have %s more messages since last refresh."
+ (notmuch-hello-nice-number diff-count)))
+ ((< diff-count 0)
+ (message "You have %s fewer messages since last refresh."
+ (notmuch-hello-nice-number (- diff-count)))))
+ (setq notmuch-hello-refresh-count new-count))))
+
+ (add-hook 'notmuch-hello-refresh-hook 'notmuch-hello-refresh-status-message)
+
+## Replacing tabs with spaces in subject and header
+
+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-emacs#notmuch_init_file) to replace
+tabs with spaces in subject lines:
+
+ (defun notmuch-show-subject-tabs-to-spaces ()
+ "Replace tabs with spaces in subject line."
+ (goto-char (point-min))
+ (when (re-search-forward "^Subject:" nil t)
+ (while (re-search-forward "\t" (line-end-position) t)
+ (replace-match " " nil nil))))
+
+ (add-hook 'notmuch-show-markup-headers-hook 'notmuch-show-subject-tabs-to-spaces)
+
+And in header lines (this will only work with the yet to be released
+notmuch version 0.15):
+
+ (defun notmuch-show-header-tabs-to-spaces ()
+ "Replace tabs with spaces in header line."
+ (setq header-line-format
+ (notmuch-show-strip-re
+ (replace-regexp-in-string "\t" " " (notmuch-show-get-subject)))))
+
+ (add-hook 'notmuch-show-hook 'notmuch-show-header-tabs-to-spaces)
+
+## Hiding unread messages in notmuch-show
+
+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](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:
+
+ (defun expand-only-unread-hook () (interactive)
+ (let ((unread nil)
+ (open (notmuch-show-get-message-ids-for-open-messages)))
+ (notmuch-show-mapc (lambda ()
+ (when (member "unread" (notmuch-show-get-tags))
+ (setq unread t))))
+ (when unread
+ (let ((notmuch-show-hook (remove 'expand-only-unread-hook notmuch-show-hook)))
+ (notmuch-show-filter-thread "tag:unread")))))
+
+ (add-hook 'notmuch-show-hook 'expand-only-unread-hook)
+
+## Changing the color of a saved search based on some other search
+
+I like to have a saved search for my inbox, but have it change color when there
+are thread with unread messages in the inbox. I accomplish this with the
+following code in my emacs config:
+
+ (defun color-inbox-if-unread () (interactive)
+ (save-excursion
+ (goto-char (point-min))
+ (let ((cnt (car (process-lines "notmuch" "count" "tag:inbox and tag:unread"))))
+ (when (> (string-to-number cnt) 0)
+ (save-excursion
+ (when (search-forward "inbox" (point-max) t)
+ (let* ((overlays (overlays-in (match-beginning 0) (match-end 0)))
+ (overlay (car overlays)))
+ (when overlay
+ (overlay-put overlay 'face '((:inherit bold) (:foreground "green")))))))))))
+ (add-hook 'notmuch-hello-refresh-hook 'color-inbox-if-unread)
+
+## Linking to notmuch messages and threads from the Circe IRC client
+
+[Circe](https://github.com/jorgenschaefer/circe/wiki) is an IRC client for emacs.
+To have clickable buttons for notmuch messages and threads, add the following to
+`lui-buttons-list` (using, e.g. M-x customize-variable)
+
+ ("\\(?:id\\|mid\\|thread\\):[0-9A-Za-z][0-9A-Za-z.@-]*" 0 notmuch-show 0)
+
+If you have notmuch-pick installed, it works fine for this as well.
+
+## Linking to notmuch messages from org-mode
+
+Support for linking to notmuch messages is distributed with org-mode,
+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")
+
+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 "^ol-notmuch.el$")))
+ (if m (add-to-list 'load-path (file-name-directory (car m)))))))
+
+Then
+
+ (require 'ol-notmuch)
+
+In general it is nice to have a key for org-links (not just for notmuch). For example
+
+ (define-key global-map "\C-c l" 'org-store-link)
+
+If you're using `use-package` the package can be loaded using the following:
+
+```emacs-lisp
+(use-package ol-notmuch
+ :ensure t
+ :bind
+ ("C-c l" . org-store-link))
+```
+
+Note the package was renamed from `org-notmuch` to `ol-notmuch` in recent
+versions of org-mode. If you're using an old version of notmuch you might want
+to `(require 'org-notmuch)` instead.
+
+## Viewing diffs in notmuch
+
+The following code allows you to view an inline patch in diff-mode
+directly from notmuch. This means that normal diff-mode commands like
+refine, next hunk etc all work.
+
+ (defun my-notmuch-show-view-as-patch ()
+ "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-bury-or-kill-this-buffer)
+ (switch-to-buffer buf)
+ (let ((inhibit-read-only t))
+ (erase-buffer)
+ (insert subject)
+ (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 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).
+
+## Applying patches to git repositories
+
+The `notmuch-extract-thread-patches` and
+`notmuch-extract-message-patches` commands from the `elpa-mailscripts`
+package in Debian (and its derivatives) can do this for you.