debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-22 02:48:08 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/emacs/notmuch-address.el

438 lines
16 KiB
EmacsLisp
Raw Normal View History

emacs: use lexical-bindings in all libraries Doing so causes many new compile warnings. Some of these warnings concern genuine changes in behavior that have to be addressed right away. Many other warnings are due to unused variables. Nothing has changed here, except that the byte-compiler can now detect these pre-existing and harmless issues. We delay addressing these issues so that we can focus on the important ones here. A third group of warnings concern arguments that are not actually used inside the function but which cannot be removed because the functions signature is dictated by some outside convention. Silencing these warning is also delayed until subsequent commits.
2021-01-10 15:00:47 +01:00
;;; notmuch-address.el --- address completion with notmuch -*- lexical-binding: t -*-
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
;;
;; Copyright © David Edmondson
;;
;; This file is part of Notmuch.
;;
;; Notmuch is free software: you can redistribute it and/or modify it
;; under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;;
;; Notmuch is distributed in the hope that it will be useful, but
;; WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;; General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
Use https instead of http where possible Many of the external links found in the notmuch source can be resolved using https instead of http. This changeset addresses as many as i could find, without touching the e-mail corpus or expected outputs found in tests.
2016-06-02 18:26:14 +02:00
;; along with Notmuch. If not, see <https://www.gnu.org/licenses/>.
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
;;
;; Authors: David Edmondson <dme@dme.org>
emacs: Fix packaging Refer to (info "(elisp) Library Headers") for package conventions.
2016-04-13 09:58:47 +02:00
;;; Code:
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
(require 'message)
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(require 'notmuch-parser)
(require 'notmuch-lib)
Emacs: Add address completion based on company-mode When company-mode is available (Emacs >= 24), address completion candidates are shown in a nice popup box. This is triggered either by pressing TAB or by waiting a while during typing an address. The completion is based entirely on the asynchronous address harvesting from notmuch-address.el so the GUI is theoretically not blocked for long time. The completion works similarly as the TAB-initiated completion from notmuch-address.el, i.e. quick harvest based on user input is executed first and only after full harvesting is finished, in-memory cached data is used. [Improved by David Bremner]
2015-10-27 00:22:49 +01:00
(require 'notmuch-company)
emacs: make headings outline-minor-mode compatible `outline-minor-mode' treats comments that begin with three or more semicolons as headings. That makes it very convenient to navigate code and to show/hide parts of a file. Elips libraries typically have four top-level sections, e.g.: ;;; notmuch.el --- run notmuch within emacs... ;;; Commentary:... ;;; Code:... ;;; notmuch.el ends here In this package many libraries lack a "Commentary:" section, which is not optimal but okay for most libraries, except major entry points. Depending on how one chooses to look at it, the "... ends here" line is not really a heading that begins a section, because it should never have a "section" body (after all it marks eof). If the file is rather short, then I left "Code:" as the only section that contains code. Otherwise I split the file into multiple sibling sections. The "Code:" section continues to contain `require' and `declare-function' forms and other such "front matter". If and only if I have split the code into multiple sections anyway, then I also added an additional section named just "_" before the `provide' form and shortly before the "...end here" line. This section could also be called "Back matter", but I feel it would be distracting to be that explicit about it. (The IMO unnecessary but unfortunately still obligatory "... ends here" line is already distracting enough as far as I am concerned.) Before this commit some libraries already uses section headings, some of them consistently. When a library already had some headings, then this commit often sticks to that style, even at the cost inconsistent styling across all libraries. A very limited number of variable and function definitions have to be moved around because they would otherwise end up in sections they do not belong into. Sections, including but not limited to their heading, can and should be further improved in the future.
2021-01-10 15:00:46 +01:00
Emacs: Add address completion based on company-mode When company-mode is available (Emacs >= 24), address completion candidates are shown in a nice popup box. This is triggered either by pressing TAB or by waiting a while during typing an address. The completion is based entirely on the asynchronous address harvesting from notmuch-address.el so the GUI is theoretically not blocked for long time. The completion works similarly as the TAB-initiated completion from notmuch-address.el, i.e. quick harvest based on user input is executed first and only after full harvesting is finished, in-memory cached data is used. [Improved by David Bremner]
2015-10-27 00:22:49 +01:00
(declare-function company-manual-begin "company")
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
emacs: make headings outline-minor-mode compatible `outline-minor-mode' treats comments that begin with three or more semicolons as headings. That makes it very convenient to navigate code and to show/hide parts of a file. Elips libraries typically have four top-level sections, e.g.: ;;; notmuch.el --- run notmuch within emacs... ;;; Commentary:... ;;; Code:... ;;; notmuch.el ends here In this package many libraries lack a "Commentary:" section, which is not optimal but okay for most libraries, except major entry points. Depending on how one chooses to look at it, the "... ends here" line is not really a heading that begins a section, because it should never have a "section" body (after all it marks eof). If the file is rather short, then I left "Code:" as the only section that contains code. Otherwise I split the file into multiple sibling sections. The "Code:" section continues to contain `require' and `declare-function' forms and other such "front matter". If and only if I have split the code into multiple sections anyway, then I also added an additional section named just "_" before the `provide' form and shortly before the "...end here" line. This section could also be called "Back matter", but I feel it would be distracting to be that explicit about it. (The IMO unnecessary but unfortunately still obligatory "... ends here" line is already distracting enough as far as I am concerned.) Before this commit some libraries already uses section headings, some of them consistently. When a library already had some headings, then this commit often sticks to that style, even at the cost inconsistent styling across all libraries. A very limited number of variable and function definitions have to be moved around because they would otherwise end up in sections they do not belong into. Sections, including but not limited to their heading, can and should be further improved in the future.
2021-01-10 15:00:46 +01:00
;;; Cache internals
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(defvar notmuch-address-last-harvest 0
emacs docstrings: consistent indentation, newlines, periods Fixed emacs docstrings to be consistent. No functional change. - removed some (accidental) indentation - removed some trailing newlines - added trailing periods where missing (some exclusions)
2020-05-24 21:17:56 +02:00
"Time of last address harvest.")
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(defvar notmuch-address-completions (make-hash-table :test 'equal)
"Hash of email addresses for completion during email composition.
emacs docstrings: consistent indentation, newlines, periods Fixed emacs docstrings to be consistent. No functional change. - removed some (accidental) indentation - removed some trailing newlines - added trailing periods where missing (some exclusions)
2020-05-24 21:17:56 +02:00
This variable is set by calling `notmuch-address-harvest'.")
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(defvar notmuch-address-full-harvest-finished nil
emacs: misc doc-string improvements
2020-11-16 22:28:31 +01:00
"Whether full completion address harvesting has finished.
Use `notmuch-address--harvest-ready' to access as that will load
a saved hash if necessary (and available).")
emacs: address: move address-full-harvest-finished to a function This makes the code access notmuch-address-full-harvest-finished via a helper function, notmuch-address--harvest-ready. Later we will use this to check whether we can load the harvest instead of regenerating it.
2016-11-20 17:50:33 +01:00
(defun notmuch-address--harvest-ready ()
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
"Return t if there is a full address hash available.
If the hash is not present it attempts to load a saved hash."
(or notmuch-address-full-harvest-finished
(notmuch-address--load-address-hash)))
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
emacs: make headings outline-minor-mode compatible `outline-minor-mode' treats comments that begin with three or more semicolons as headings. That makes it very convenient to navigate code and to show/hide parts of a file. Elips libraries typically have four top-level sections, e.g.: ;;; notmuch.el --- run notmuch within emacs... ;;; Commentary:... ;;; Code:... ;;; notmuch.el ends here In this package many libraries lack a "Commentary:" section, which is not optimal but okay for most libraries, except major entry points. Depending on how one chooses to look at it, the "... ends here" line is not really a heading that begins a section, because it should never have a "section" body (after all it marks eof). If the file is rather short, then I left "Code:" as the only section that contains code. Otherwise I split the file into multiple sibling sections. The "Code:" section continues to contain `require' and `declare-function' forms and other such "front matter". If and only if I have split the code into multiple sections anyway, then I also added an additional section named just "_" before the `provide' form and shortly before the "...end here" line. This section could also be called "Back matter", but I feel it would be distracting to be that explicit about it. (The IMO unnecessary but unfortunately still obligatory "... ends here" line is already distracting enough as far as I am concerned.) Before this commit some libraries already uses section headings, some of them consistently. When a library already had some headings, then this commit often sticks to that style, even at the cost inconsistent styling across all libraries. A very limited number of variable and function definitions have to be moved around because they would otherwise end up in sections they do not belong into. Sections, including but not limited to their heading, can and should be further improved in the future.
2021-01-10 15:00:46 +01:00
;;; Options
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(defcustom notmuch-address-command 'internal
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
"Determines how address completion candidates are generated.
emacs: allow opting out of notmuch's address completion IMO Notmuch should not override the default completion mechanism by default, at least not globally. But since users are already used to this behavior it is probably too late to change it. Do the next best thing and at least allow users to opt out.
2021-01-10 15:01:11 +01:00
If this is a string, then that string should be an external
program, which must take a single argument (searched string)
and output a list of completion candidates, one per line.
If this is the symbol `internal', then an implementation is used
that relies on the \"notmuch address\" command, but does not use
any third-party (i.e. \"external\") programs.
If this is the symbol `as-is', then Notmuch does not modify the
value of `message-completion-alist'. This option has to be set to
this value before `notmuch' is loaded, otherwise the modification
to `message-completion-alist' may already have taken place. This
setting obviously does not prevent `message-completion-alist'
from being modified at all; the user or some third-party package
may still modify it.
Finally, if this is nil, then address completion is disabled."
emacs: replace use of notmuch-address-message-insinuate This allows e.g. Gnus users to load this file without changing message-mode behaviour. This will disable completion for those that did not customize the variable but relied on the existence of a file named "notmuch-addresses" in their path. In the next commit the default behaviour will change to use a "workalike" internal completion mechanism.
2015-10-27 00:22:47 +01:00
:type '(radio
emacs: allow opting out of notmuch's address completion IMO Notmuch should not override the default completion mechanism by default, at least not globally. But since users are already used to this behavior it is probably too late to change it. Do the next best thing and at least allow users to opt out.
2021-01-10 15:01:11 +01:00
(const :tag "Use internal address completion" internal)
(string :tag "Use external completion command")
(const :tag "Disable address completion" nil)
(const :tag "Use default or third-party mechanism" as-is))
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
:group 'notmuch-send
emacs: fully add the notmuch-address customize group We now have several customizable options for address completion. There is a customize group notmuch-address but it only contains one of these options. Add all the others, and make it part of the notmuch customize group.
2017-01-28 11:38:27 +01:00
:group 'notmuch-address
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
:group 'notmuch-external)
(defcustom notmuch-address-internal-completion '(sent nil)
"Determines how internal address completion generates candidates.
emacs: Improve doc-strings - The first sentence should fit on the first line in full. This is even the case when that causes the line to get a bit long. If it gets very long, then it should be made shorter. - Even even the second sentence would fit on the first line, if it just provides some details, then it shouldn't be done. - Symbols are quoted like `so'. - There is no clear rule on how to (not) quote non-atomic s-expressions, but quoting like '(this) is definitely weird. - It is a good idea to remember that \" becomes " and to take that in mind when adjusting the automatic filling by hand. - Use the imperative form. - Arguments are written in all uppercase.
2020-08-08 13:49:50 +02:00
This should be a list of the form (DIRECTION FILTER), where
emacs docstrings: consistent indentation, newlines, periods Fixed emacs docstrings to be consistent. No functional change. - removed some (accidental) indentation - removed some trailing newlines - added trailing periods where missing (some exclusions)
2020-05-24 21:17:56 +02:00
DIRECTION is either sent or received and specifies whether the
candidates are searched in messages sent by the user or received
by the user (note received by is much faster), and FILTER is
emacs: Improve doc-strings - The first sentence should fit on the first line in full. This is even the case when that causes the line to get a bit long. If it gets very long, then it should be made shorter. - Even even the second sentence would fit on the first line, if it just provides some details, then it shouldn't be done. - Symbols are quoted like `so'. - There is no clear rule on how to (not) quote non-atomic s-expressions, but quoting like '(this) is definitely weird. - It is a good idea to remember that \" becomes " and to take that in mind when adjusting the automatic filling by hand. - Use the imperative form. - Arguments are written in all uppercase.
2020-08-08 13:49:50 +02:00
either nil or a filter-string, such as \"date:1y..\" to append to
the query."
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
:type '(list :tag "Use internal address completion"
(radio
:tag "Base completion on messages you have"
:value sent
(const :tag "sent (more accurate)" sent)
(const :tag "received (faster)" received))
(radio :tag "Filter messages used for completion"
(const :tag "Use all messages" nil)
(string :tag "Filter query")))
;; We override set so that we can clear the cache when this changes
:set (lambda (symbol value)
(set-default symbol value)
(setq notmuch-address-last-harvest 0)
(setq notmuch-address-completions (clrhash notmuch-address-completions))
(setq notmuch-address-full-harvest-finished nil))
emacs: logically group def{custom,face}s To allow for expansion whilst keeping everything tidy and organized, move all defcustom/defface variables to the following subgroups, defined in notmuch-lib.el: - Hello - Search - Show - Send - Crypto - Hooks - External Commands - Appearance As an added benefit, defcustom keyword args are now consistently ordered as they appear @ defcustom's docstring (OCD much?). Proper defgroup docstrings and various other improvements by courtesy of Austin Clements.
2012-01-16 11:38:33 +01:00
:group 'notmuch-send
emacs: fully add the notmuch-address customize group We now have several customizable options for address completion. There is a customize group notmuch-address but it only contains one of these options. Add all the others, and make it part of the notmuch customize group.
2017-01-28 11:38:27 +01:00
:group 'notmuch-address
emacs: logically group def{custom,face}s To allow for expansion whilst keeping everything tidy and organized, move all defcustom/defface variables to the following subgroups, defined in notmuch-lib.el: - Hello - Search - Show - Send - Crypto - Hooks - External Commands - Appearance As an added benefit, defcustom keyword args are now consistently ordered as they appear @ defcustom's docstring (OCD much?). Proper defgroup docstrings and various other improvements by courtesy of Austin Clements.
2012-01-16 11:38:33 +01:00
:group 'notmuch-external)
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
(defcustom notmuch-address-save-filename nil
"Filename to save the cached completion addresses.
All the addresses notmuch uses for address completion will be
emacs: Improve doc-strings - The first sentence should fit on the first line in full. This is even the case when that causes the line to get a bit long. If it gets very long, then it should be made shorter. - Even even the second sentence would fit on the first line, if it just provides some details, then it shouldn't be done. - Symbols are quoted like `so'. - There is no clear rule on how to (not) quote non-atomic s-expressions, but quoting like '(this) is definitely weird. - It is a good idea to remember that \" becomes " and to take that in mind when adjusting the automatic filling by hand. - Use the imperative form. - Arguments are written in all uppercase.
2020-08-08 13:49:50 +02:00
cached in this file. This has obvious privacy implications so
you should make sure it is not somewhere publicly readable."
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
:type '(choice (const :tag "Off" nil)
(file :tag "Filename"))
:group 'notmuch-send
emacs: fully add the notmuch-address customize group We now have several customizable options for address completion. There is a customize group notmuch-address but it only contains one of these options. Add all the others, and make it part of the notmuch customize group.
2017-01-28 11:38:27 +01:00
:group 'notmuch-address
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
:group 'notmuch-external)
emacs/notmuch-address.el: add notmuch-address-selection-function Added a customizable variable notmuch-address-selection-function and the function with the same name to provide a way for user to change the function called to do address selection. By default the functionality is exactly the same as it has been so far; completing-read is called with the same parameters as before. Setting equivalent lambda expression in place of using notmuch-address-selection-function function is done as follows: (setq notmuch-address-selection-function (lambda (prompt collection initial-input) (completing-read prompt collection nil nil initial-input))) For example drop-in replacement with ido-completing-read can be done easily as an one alternative to the default.
2013-04-03 17:08:54 +02:00
(defcustom notmuch-address-selection-function 'notmuch-address-selection-function
emacs: Improve doc-strings - The first sentence should fit on the first line in full. This is even the case when that causes the line to get a bit long. If it gets very long, then it should be made shorter. - Even even the second sentence would fit on the first line, if it just provides some details, then it shouldn't be done. - Symbols are quoted like `so'. - There is no clear rule on how to (not) quote non-atomic s-expressions, but quoting like '(this) is definitely weird. - It is a good idea to remember that \" becomes " and to take that in mind when adjusting the automatic filling by hand. - Use the imperative form. - Arguments are written in all uppercase.
2020-08-08 13:49:50 +02:00
"The function to select address from given list.
The function is called with PROMPT, COLLECTION, and INITIAL-INPUT
as arguments (subset of what `completing-read' can be called
with). While executed the value of `completion-ignore-case'
is t. See documentation of function
`notmuch-address-selection-function' to know how address
selection is made by default."
emacs/notmuch-address.el: add notmuch-address-selection-function Added a customizable variable notmuch-address-selection-function and the function with the same name to provide a way for user to change the function called to do address selection. By default the functionality is exactly the same as it has been so far; completing-read is called with the same parameters as before. Setting equivalent lambda expression in place of using notmuch-address-selection-function function is done as follows: (setq notmuch-address-selection-function (lambda (prompt collection initial-input) (completing-read prompt collection nil nil initial-input))) For example drop-in replacement with ido-completing-read can be done easily as an one alternative to the default.
2013-04-03 17:08:54 +02:00
:type 'function
:group 'notmuch-send
emacs: fully add the notmuch-address customize group We now have several customizable options for address completion. There is a customize group notmuch-address but it only contains one of these options. Add all the others, and make it part of the notmuch customize group.
2017-01-28 11:38:27 +01:00
:group 'notmuch-address
emacs/notmuch-address.el: add notmuch-address-selection-function Added a customizable variable notmuch-address-selection-function and the function with the same name to provide a way for user to change the function called to do address selection. By default the functionality is exactly the same as it has been so far; completing-read is called with the same parameters as before. Setting equivalent lambda expression in place of using notmuch-address-selection-function function is done as follows: (setq notmuch-address-selection-function (lambda (prompt collection initial-input) (completing-read prompt collection nil nil initial-input))) For example drop-in replacement with ido-completing-read can be done easily as an one alternative to the default.
2013-04-03 17:08:54 +02:00
:group 'notmuch-external)
emacs: rename notmuch-address-completion-hook to notmuch-address-post-completion-functions Apparently it is a (not completely adhered to) emacs convention [1] that only hooks that don't take arguments end in 'hook' [1]: https://www.gnu.org/software/emacs/manual/html_node/elisp/Hooks.html
2016-11-13 13:52:17 +01:00
(defcustom notmuch-address-post-completion-functions nil
emacs: add notmuch-address-post-completion-hook This hook can be used to update the message based on the results of address completion. For example using message-templ or gnus-alias to set the From address based on the To address just completed. The post-completion command is added to the notmuch-company backend to ensure that the hook is also called company completion is started without going through notmuch-address-expand-name. See the docstring of `company-backends' for more information.
2016-11-04 02:02:43 +01:00
"Functions called after completing address.
The completed address is passed as an argument to each function.
Note that this hook will be invoked for completion in headers
emacs docstrings: consistent indentation, newlines, periods Fixed emacs docstrings to be consistent. No functional change. - removed some (accidental) indentation - removed some trailing newlines - added trailing periods where missing (some exclusions)
2020-05-24 21:17:56 +02:00
matching `notmuch-address-completion-headers-regexp'."
emacs: add notmuch-address-post-completion-hook This hook can be used to update the message based on the results of address completion. For example using message-templ or gnus-alias to set the From address based on the To address just completed. The post-completion command is added to the notmuch-company backend to ensure that the hook is also called company completion is started without going through notmuch-address-expand-name. See the docstring of `company-backends' for more information.
2016-11-04 02:02:43 +01:00
:type 'hook
:group 'notmuch-address
:group 'notmuch-hooks)
emacs: make headings outline-minor-mode compatible `outline-minor-mode' treats comments that begin with three or more semicolons as headings. That makes it very convenient to navigate code and to show/hide parts of a file. Elips libraries typically have four top-level sections, e.g.: ;;; notmuch.el --- run notmuch within emacs... ;;; Commentary:... ;;; Code:... ;;; notmuch.el ends here In this package many libraries lack a "Commentary:" section, which is not optimal but okay for most libraries, except major entry points. Depending on how one chooses to look at it, the "... ends here" line is not really a heading that begins a section, because it should never have a "section" body (after all it marks eof). If the file is rather short, then I left "Code:" as the only section that contains code. Otherwise I split the file into multiple sibling sections. The "Code:" section continues to contain `require' and `declare-function' forms and other such "front matter". If and only if I have split the code into multiple sections anyway, then I also added an additional section named just "_" before the `provide' form and shortly before the "...end here" line. This section could also be called "Back matter", but I feel it would be distracting to be that explicit about it. (The IMO unnecessary but unfortunately still obligatory "... ends here" line is already distracting enough as far as I am concerned.) Before this commit some libraries already uses section headings, some of them consistently. When a library already had some headings, then this commit often sticks to that style, even at the cost inconsistent styling across all libraries. A very limited number of variable and function definitions have to be moved around because they would otherwise end up in sections they do not belong into. Sections, including but not limited to their heading, can and should be further improved in the future.
2021-01-10 15:00:46 +01:00
(defcustom notmuch-address-use-company t
"If available, use company mode for address completion."
:type 'boolean
:group 'notmuch-send
:group 'notmuch-address)
;;; Setup
emacs/notmuch-address.el: add notmuch-address-selection-function Added a customizable variable notmuch-address-selection-function and the function with the same name to provide a way for user to change the function called to do address selection. By default the functionality is exactly the same as it has been so far; completing-read is called with the same parameters as before. Setting equivalent lambda expression in place of using notmuch-address-selection-function function is done as follows: (setq notmuch-address-selection-function (lambda (prompt collection initial-input) (completing-read prompt collection nil nil initial-input))) For example drop-in replacement with ido-completing-read can be done easily as an one alternative to the default.
2013-04-03 17:08:54 +02:00
(defun notmuch-address-selection-function (prompt collection initial-input)
"Call (`completing-read'
PROMPT COLLECTION nil nil INITIAL-INPUT 'notmuch-address-history)"
(completing-read
prompt collection nil nil initial-input 'notmuch-address-history))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(defvar notmuch-address-completion-headers-regexp
"^\\(Resent-\\)?\\(To\\|B?Cc\\|Reply-To\\|From\\|Mail-Followup-To\\|Mail-Copies-To\\):")
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
(defvar notmuch-address-history nil)
(defun notmuch-address-message-insinuate ()
emacs: replace use of notmuch-address-message-insinuate This allows e.g. Gnus users to load this file without changing message-mode behaviour. This will disable completion for those that did not customize the variable but relied on the existence of a file named "notmuch-addresses" in their path. In the next commit the default behaviour will change to use a "workalike" internal completion mechanism.
2015-10-27 00:22:47 +01:00
(message "calling notmuch-address-message-insinuate is no longer needed"))
(defun notmuch-address-setup ()
emacs: allow opting out of notmuch's address completion IMO Notmuch should not override the default completion mechanism by default, at least not globally. But since users are already used to this behavior it is probably too late to change it. Do the next best thing and at least allow users to opt out.
2021-01-10 15:01:11 +01:00
(unless (eq notmuch-address-command 'as-is)
(when (and notmuch-address-use-company
(require 'company nil t))
(notmuch-company-setup))
(cl-pushnew (cons notmuch-address-completion-headers-regexp
#'notmuch-address-expand-name)
message-completion-alist :test #'equal)))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
emacs: address: allow internal completion on an individual basis This commit makes two changes. The first allows the user to override an external completion method with the internal notmuch address based completion for an individual buffer. Secondly, if the user has company-mode enabled then it sets up company mode (based on internal completion) but disables the automatic timeout completion -- the user can still activate it in when desired with standard company commands such as company-complete.
2016-05-20 22:13:03 +02:00
(defun notmuch-address-toggle-internal-completion ()
"Toggle use of internal completion for current buffer.
This overrides the global setting for address completion and
toggles the setting in this buffer."
(interactive)
(if (local-variable-p 'notmuch-address-command)
(kill-local-variable 'notmuch-address-command)
emacs: Remove notmuch-setq-local Just use setq-local, which existed since Emacs 24.3.
2020-08-08 13:50:04 +02:00
(setq-local notmuch-address-command 'internal))
emacs: Use 'when' instead of 'if' when there is no ELSE part
2020-08-08 13:49:43 +02:00
(when (boundp 'company-idle-delay)
(if (local-variable-p 'company-idle-delay)
(kill-local-variable 'company-idle-delay)
emacs: Remove notmuch-setq-local Just use setq-local, which existed since Emacs 24.3.
2020-08-08 13:50:04 +02:00
(setq-local company-idle-delay nil))))
emacs: address: allow internal completion on an individual basis This commit makes two changes. The first allows the user to override an external completion method with the internal notmuch address based completion for an individual buffer. Secondly, if the user has company-mode enabled then it sets up company mode (based on internal completion) but disables the automatic timeout completion -- the user can still activate it in when desired with standard company commands such as company-complete.
2016-05-20 22:13:03 +02:00
emacs: make headings outline-minor-mode compatible `outline-minor-mode' treats comments that begin with three or more semicolons as headings. That makes it very convenient to navigate code and to show/hide parts of a file. Elips libraries typically have four top-level sections, e.g.: ;;; notmuch.el --- run notmuch within emacs... ;;; Commentary:... ;;; Code:... ;;; notmuch.el ends here In this package many libraries lack a "Commentary:" section, which is not optimal but okay for most libraries, except major entry points. Depending on how one chooses to look at it, the "... ends here" line is not really a heading that begins a section, because it should never have a "section" body (after all it marks eof). If the file is rather short, then I left "Code:" as the only section that contains code. Otherwise I split the file into multiple sibling sections. The "Code:" section continues to contain `require' and `declare-function' forms and other such "front matter". If and only if I have split the code into multiple sections anyway, then I also added an additional section named just "_" before the `provide' form and shortly before the "...end here" line. This section could also be called "Back matter", but I feel it would be distracting to be that explicit about it. (The IMO unnecessary but unfortunately still obligatory "... ends here" line is already distracting enough as far as I am concerned.) Before this commit some libraries already uses section headings, some of them consistently. When a library already had some headings, then this commit often sticks to that style, even at the cost inconsistent styling across all libraries. A very limited number of variable and function definitions have to be moved around because they would otherwise end up in sections they do not belong into. Sections, including but not limited to their heading, can and should be further improved in the future.
2021-01-10 15:00:46 +01:00
;;; Completion
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(defun notmuch-address-matching (substring)
"Returns a list of completion candidates matching SUBSTRING.
The candidates are taken from `notmuch-address-completions'."
(let ((candidates)
(re (regexp-quote substring)))
emacs: deal with unused lexical arguments and variables The previous commit switched to lexical-binding but without dealing with the new warnings about unused lexical arguments and variables. This commit deals with most of them, in most cases by either removing leftover bindings that are actually unnecessary, or by marking certain arguments as "known to be unused" by prefixing their names with "_". In the case of the functions named `notmuch-show-insert-...' the amount of silencing that is required is a bit extreme and we might want to investigate if there is a better way. In the case of `notmuch-mua-mail', ignoring CONTINUE means that we do not fully follow the intended behavior described in `compose-mail's doc-string.
2021-01-10 15:00:48 +01:00
(maphash (lambda (key _val)
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(when (string-match re key)
(push key candidates)))
notmuch-address-completions)
candidates))
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
(defun notmuch-address-options (original)
emacs: Improve doc-strings - The first sentence should fit on the first line in full. This is even the case when that causes the line to get a bit long. If it gets very long, then it should be made shorter. - Even even the second sentence would fit on the first line, if it just provides some details, then it shouldn't be done. - Symbols are quoted like `so'. - There is no clear rule on how to (not) quote non-atomic s-expressions, but quoting like '(this) is definitely weird. - It is a good idea to remember that \" becomes " and to take that in mind when adjusting the automatic filling by hand. - Use the imperative form. - Arguments are written in all uppercase.
2020-08-08 13:49:50 +02:00
"Return a list of completion candidates.
Use either elisp-based implementation or older implementation
requiring external commands."
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(cond
((eq notmuch-address-command 'internal)
emacs: address: move address-full-harvest-finished to a function This makes the code access notmuch-address-full-harvest-finished via a helper function, notmuch-address--harvest-ready. Later we will use this to check whether we can load the harvest instead of regenerating it.
2016-11-20 17:50:33 +01:00
(unless (notmuch-address--harvest-ready)
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
;; First, run quick synchronous harvest based on what the user
emacs: Shorten long lines
2020-08-08 13:49:36 +02:00
;; entered so far.
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(notmuch-address-harvest original t))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(prog1 (notmuch-address-matching original)
emacs: Shorten long lines
2020-08-08 13:49:36 +02:00
;; Then start the (potentially long-running) full asynchronous
;; harvest if necessary.
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(notmuch-address-harvest-trigger)))
(t
emacs: wrap process-lines Initially just set the working directory, to avoid (the implicit) call-process crashing when the default-directory points to a non-existent location. Use of a macro here is over-engineering for this change, but the same change needs to be applied to several other process creation primitives.
2021-08-29 21:23:29 +02:00
(notmuch--process-lines notmuch-address-command original))))
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
(defun notmuch-address-expand-name ()
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(cond
((and (eq notmuch-address-command 'internal)
notmuch-address-use-company
(bound-and-true-p company-mode))
(company-manual-begin))
(notmuch-address-command
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(let* ((end (point))
(beg (save-excursion
(re-search-backward "\\(\\`\\|[\n:,]\\)[ \t]*")
(goto-char (match-end 0))
(point)))
(orig (buffer-substring-no-properties beg end))
(completion-ignore-case t)
(options (with-temp-message "Looking for completion candidates..."
(notmuch-address-options orig)))
(num-options (length options))
(chosen (cond
((eq num-options 0)
nil)
((eq num-options 1)
(car options))
(t
(funcall notmuch-address-selection-function
(format "Address (%s matches): " num-options)
emacs: notmuch-address-expand-name: use the actual initial-input Users may type some text into the buffer on an address line, before actually invoking address completion. We now use that text as the initial input when we begin address completion. Previously we did knowingly replace the actual initial input with some completion candidate that happens to match. Which candidate is used is essentially random, at least when the actual initial input is short. As a result users very often had to begin completion by deleting the less than helpful "initial input".
2021-01-10 15:01:12 +01:00
options
orig)))))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(if chosen
(progn
(push chosen notmuch-address-history)
(delete-region beg end)
emacs: add notmuch-address-post-completion-hook This hook can be used to update the message based on the results of address completion. For example using message-templ or gnus-alias to set the From address based on the To address just completed. The post-completion command is added to the notmuch-company backend to ensure that the hook is also called company completion is started without going through notmuch-address-expand-name. See the docstring of `company-backends' for more information.
2016-11-04 02:02:43 +01:00
(insert chosen)
emacs: Shorten long lines
2020-08-08 13:49:36 +02:00
(run-hook-with-args 'notmuch-address-post-completion-functions
chosen))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(message "No matches.")
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(ding))))
(t nil)))
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
emacs: make headings outline-minor-mode compatible `outline-minor-mode' treats comments that begin with three or more semicolons as headings. That makes it very convenient to navigate code and to show/hide parts of a file. Elips libraries typically have four top-level sections, e.g.: ;;; notmuch.el --- run notmuch within emacs... ;;; Commentary:... ;;; Code:... ;;; notmuch.el ends here In this package many libraries lack a "Commentary:" section, which is not optimal but okay for most libraries, except major entry points. Depending on how one chooses to look at it, the "... ends here" line is not really a heading that begins a section, because it should never have a "section" body (after all it marks eof). If the file is rather short, then I left "Code:" as the only section that contains code. Otherwise I split the file into multiple sibling sections. The "Code:" section continues to contain `require' and `declare-function' forms and other such "front matter". If and only if I have split the code into multiple sections anyway, then I also added an additional section named just "_" before the `provide' form and shortly before the "...end here" line. This section could also be called "Back matter", but I feel it would be distracting to be that explicit about it. (The IMO unnecessary but unfortunately still obligatory "... ends here" line is already distracting enough as far as I am concerned.) Before this commit some libraries already uses section headings, some of them consistently. When a library already had some headings, then this commit often sticks to that style, even at the cost inconsistent styling across all libraries. A very limited number of variable and function definitions have to be moved around because they would otherwise end up in sections they do not belong into. Sections, including but not limited to their heading, can and should be further improved in the future.
2021-01-10 15:00:46 +01:00
;;; Harvest
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(defun notmuch-address-harvest-addr (result)
emacs: avoid unnecessary let-bindings To some extend this is a personal preference, but the preference is strongly dependent on whether one is used to a language that makes it necessary to use variables like this. This makes it perfectly clear that we are first getting and then using a "foo": (use-foo (get-foo)) Sure this has to be read "inside out", but that's something one better gets used to quickly when dealing with lisp. I don't understand why one would want to write this instead: (let ((the-foo (get-foo))) (use-foo the-foo)) Both `get-foo' and `use-foo' are named in a way that make it very clear that we are dealing with a "foo". Storing the value in an additional variable `the-foo' does not make this any more clear. On the contrary I makes the reader wonder why the author choose to use a variable. Is the value used more than once? Is the value being retrieved in one context and then used in another (e.g. when the current buffer changes)?
2021-01-10 15:01:06 +01:00
(puthash (plist-get result :name-addr)
t notmuch-address-completions))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(defun notmuch-address-harvest-filter (proc string)
(when (buffer-live-p (process-buffer proc))
(with-current-buffer (process-buffer proc)
(save-excursion
(goto-char (point-max))
(insert string))
(notmuch-sexp-parse-partial-list
emacs: various cosmetic improvements
2021-01-13 18:37:50 +01:00
'notmuch-address-harvest-addr (process-buffer proc)))))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(defvar notmuch-address-harvest-procs '(nil . nil)
"The currently running harvests.
emacs docstrings: consistent indentation, newlines, periods Fixed emacs docstrings to be consistent. No functional change. - removed some (accidental) indentation - removed some trailing newlines - added trailing periods where missing (some exclusions)
2020-05-24 21:17:56 +02:00
The car is a partial harvest, and the cdr is a full harvest.")
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(defun notmuch-address-harvest (&optional addr-prefix synchronous callback)
"Collect addresses completion candidates.
It queries the notmuch database for messages sent/received (as
emacs: always use elisp quoting style in doc-strings Emacs doc-strings use neither markdown nor lisp symbol quoting.
2020-11-16 22:28:30 +01:00
configured with `notmuch-address-command') by the user, collects
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
destination/source addresses from those messages and stores them
in `notmuch-address-completions'.
If ADDR-PREFIX is not nil, only messages with to/from addresses
matching ADDR-PREFIX*' are queried.
Address harvesting may take some time so the address collection runs
asynchronously unless SYNCHRONOUS is t. In case of asynchronous
execution, CALLBACK is called when harvesting finishes."
(let* ((sent (eq (car notmuch-address-internal-completion) 'sent))
(config-query (cadr notmuch-address-internal-completion))
emacs: Use 'and' instead of 'when' when the return value matters Also do so for some 'if' forms that lack an ELSE part. Even go as far as using 'and' and 'not' instead of 'unless'.
2020-08-08 13:49:41 +02:00
(prefix-query (and addr-prefix
(format "%s:%s*"
(if sent "to" "from")
addr-prefix)))
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(from-or-to-me-query
(mapconcat (lambda (x)
(concat (if sent "from:" "to:") x))
(notmuch-user-emails) " or "))
(query (if (or prefix-query config-query)
(concat (format "(%s)" from-or-to-me-query)
emacs: Use 'and' instead of 'when' when the return value matters Also do so for some 'if' forms that lack an ELSE part. Even go as far as using 'and' and 'not' instead of 'unless'.
2020-08-08 13:49:41 +02:00
(and prefix-query
(format " and (%s)" prefix-query))
(and config-query
(format " and (%s)" config-query)))
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
from-or-to-me-query))
CLI: define and use format version 5 This is a bit of a cheat, since the format does not actually change. On the other hand it is fairly common to do something like this to shared libary SONAMEs when the ABI changes in some subtle way. It does rely on the format-version argument being early enough on the command line to generate a sensible error message.
2021-08-22 02:00:11 +02:00
(args `("address" "--format=sexp" "--format-version=5"
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
,(if sent "--output=recipients" "--output=sender")
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
"--deduplicate=address"
,query)))
(if synchronous
(mapc #'notmuch-address-harvest-addr
emacs: Fix indentation
2020-08-08 13:49:38 +02:00
(apply 'notmuch-call-notmuch-sexp args))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
;; Asynchronous
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(let* ((current-proc (if addr-prefix
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(car notmuch-address-harvest-procs)
(cdr notmuch-address-harvest-procs)))
(proc-name (format "notmuch-address-%s-harvest"
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(if addr-prefix "partial" "full")))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(proc-buf (concat " *" proc-name "*")))
;; Kill any existing process
(when current-proc
(kill-buffer (process-buffer current-proc))) ; this also kills the process
(setq current-proc
(apply 'notmuch-start-notmuch proc-name proc-buf
callback ; process sentinel
args))
(set-process-filter current-proc 'notmuch-address-harvest-filter)
(set-process-query-on-exit-flag current-proc nil)
emacs: address completion, allow sender/recipient and filters This commit lets the user customize the address completion. It makes two changes. The first change controls whether to build the address completion list based on messages you have sent or you have received (the latter is much faster). The second change add a possible filter query to limit the messages used -- for example, setting this to date:1y.. would limit the address completions to addresses used in the last year. This speeds up the address harvest and may also make the search less cluttered as old addresses may well no longer be valid.
2016-05-20 22:13:02 +02:00
(if addr-prefix
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(setcar notmuch-address-harvest-procs current-proc)
(setcdr notmuch-address-harvest-procs current-proc)))))
;; return value
nil)
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
(defvar notmuch-address--save-hash-version 1
"Version format of the save hash.")
(defun notmuch-address--get-address-hash ()
emacs: Improve doc-strings - The first sentence should fit on the first line in full. This is even the case when that causes the line to get a bit long. If it gets very long, then it should be made shorter. - Even even the second sentence would fit on the first line, if it just provides some details, then it shouldn't be done. - Symbols are quoted like `so'. - There is no clear rule on how to (not) quote non-atomic s-expressions, but quoting like '(this) is definitely weird. - It is a good idea to remember that \" becomes " and to take that in mind when adjusting the automatic filling by hand. - Use the imperative form. - Arguments are written in all uppercase.
2020-08-08 13:49:50 +02:00
"Return the saved address hash as a plist.
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
Returns nil if the save file does not exist, or it does not seem
to be a saved address hash."
emacs: Use 'and' instead of 'when' when the return value matters Also do so for some 'if' forms that lack an ELSE part. Even go as far as using 'and' and 'not' instead of 'unless'.
2020-08-08 13:49:41 +02:00
(and notmuch-address-save-filename
(condition-case nil
(with-temp-buffer
(insert-file-contents notmuch-address-save-filename)
(let ((name (read (current-buffer)))
(plist (read (current-buffer))))
;; We do two simple sanity checks on the loaded file.
;; We just check a version is specified, not that
;; it is the current version, as we are allowed to
;; over-write and a save-file with an older version.
(and (string= name "notmuch-address-hash")
(plist-get plist :version)
plist)))
;; The error case catches any of the reads failing.
(error nil))))
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
(defun notmuch-address--load-address-hash ()
"Read the saved address hash and set the corresponding variables."
(let ((load-plist (notmuch-address--get-address-hash)))
(when (and load-plist
;; If the user's setting have changed, or the version
;; has changed, return nil to make sure the new settings
;; take effect.
(equal (plist-get load-plist :completion-settings)
notmuch-address-internal-completion)
(equal (plist-get load-plist :version)
notmuch-address--save-hash-version))
emacs: Only set one variable per setq form It's a bit weird to avoid having to write the "(setq ... )" more than once, just because we can. In a language that uses '=' for the same purpose we also happily use that once per assignment. While there are no benefit to using just one 'setq' there are some drawbacks. It is not always clear on first what is a key and what a value and as a result it is easy to make a mistake. Also it becomes harder to comment out just one assignment.
2020-08-08 13:49:40 +02:00
(setq notmuch-address-last-harvest (plist-get load-plist :last-harvest))
(setq notmuch-address-completions (plist-get load-plist :completions))
(setq notmuch-address-full-harvest-finished t)
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
;; Return t to say load was successful.
t)))
(defun notmuch-address--save-address-hash ()
(when notmuch-address-save-filename
(if (or (not (file-exists-p notmuch-address-save-filename))
emacs: various comment improvements
2021-01-10 15:01:00 +01:00
;; The file exists, check it is a file we saved.
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
(notmuch-address--get-address-hash))
(with-temp-file notmuch-address-save-filename
emacs: Shorten long lines
2020-08-08 13:49:36 +02:00
(let ((save-plist
(list :version notmuch-address--save-hash-version
:completion-settings notmuch-address-internal-completion
:last-harvest notmuch-address-last-harvest
:completions notmuch-address-completions)))
emacs: address: save hash This allows the user to save the address hash so that it is much faster for the first completion after a restart. This defaults to off as there are privacy implications to saving this information. The code tries hard to avoid overwriting the wrong file. It also notes if changes have been made to any of the relevant user settings, so that the user does not get surprising results (i.e., outdated options being used). Finally it stores some version information so that is easy for us to update the format of the save file.
2016-11-20 17:50:34 +01:00
(print "notmuch-address-hash" (current-buffer))
(print save-plist (current-buffer))))
(message "\
Warning: notmuch-address-save-filename %s exists but doesn't
appear to be an address savefile. Not overwriting."
notmuch-address-save-filename))))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
(defun notmuch-address-harvest-trigger ()
(let ((now (float-time)))
(when (> (- now notmuch-address-last-harvest) 86400)
(setq notmuch-address-last-harvest now)
emacs: Shorten long lines
2020-08-08 13:49:36 +02:00
(notmuch-address-harvest
nil nil
emacs: deal with unused lexical arguments and variables The previous commit switched to lexical-binding but without dealing with the new warnings about unused lexical arguments and variables. This commit deals with most of them, in most cases by either removing leftover bindings that are actually unnecessary, or by marking certain arguments as "known to be unused" by prefixing their names with "_". In the case of the functions named `notmuch-show-insert-...' the amount of silencing that is required is a bit extreme and we might want to investigate if there is a better way. In the case of `notmuch-mua-mail', ignoring CONTINUE means that we do not fully follow the intended behavior described in `compose-mail's doc-string.
2021-01-10 15:00:48 +01:00
(lambda (_proc event)
emacs: Shorten long lines
2020-08-08 13:49:36 +02:00
;; If harvest fails, we want to try
emacs: various comment improvements
2021-01-10 15:01:00 +01:00
;; again when the trigger is next called.
emacs: Shorten long lines
2020-08-08 13:49:36 +02:00
(if (string= event "finished\n")
(progn
(notmuch-address--save-address-hash)
(setq notmuch-address-full-harvest-finished t))
(setq notmuch-address-last-harvest 0)))))))
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
emacs: make headings outline-minor-mode compatible `outline-minor-mode' treats comments that begin with three or more semicolons as headings. That makes it very convenient to navigate code and to show/hide parts of a file. Elips libraries typically have four top-level sections, e.g.: ;;; notmuch.el --- run notmuch within emacs... ;;; Commentary:... ;;; Code:... ;;; notmuch.el ends here In this package many libraries lack a "Commentary:" section, which is not optimal but okay for most libraries, except major entry points. Depending on how one chooses to look at it, the "... ends here" line is not really a heading that begins a section, because it should never have a "section" body (after all it marks eof). If the file is rather short, then I left "Code:" as the only section that contains code. Otherwise I split the file into multiple sibling sections. The "Code:" section continues to contain `require' and `declare-function' forms and other such "front matter". If and only if I have split the code into multiple sections anyway, then I also added an additional section named just "_" before the `provide' form and shortly before the "...end here" line. This section could also be called "Back matter", but I feel it would be distracting to be that explicit about it. (The IMO unnecessary but unfortunately still obligatory "... ends here" line is already distracting enough as far as I am concerned.) Before this commit some libraries already uses section headings, some of them consistently. When a library already had some headings, then this commit often sticks to that style, even at the cost inconsistent styling across all libraries. A very limited number of variable and function definitions have to be moved around because they would otherwise end up in sections they do not belong into. Sections, including but not limited to their heading, can and should be further improved in the future.
2021-01-10 15:00:46 +01:00
;;; Standalone completion
Emacs: Add address completion mechanism implemented in elisp Currently, notmuch has an address completion mechanism that requires external command to provide completion candidates. This commit adds a completion mechanism inspired by https://github.com/tjim/nevermore, which is implemented in Emacs lisp only. The preexisting address completion mechanism, activated by pressing TAB on To/Cc lines, is extended to use the new mechanism when notmuch-address-command to 'internal, which is the new default. The core of the new mechanism is the function notmuch-address-harvest, which collects the completion candidates from the notmuch database and stores them in notmuch-address-completions variable. The address harvesting can run either synchronously (same as with the previous mechanism) or asynchronously. When the user presses TAB for the first time, synchronous harvesting limited to user entered text is performed. If the entered text is reasonably long, this operation is relatively fast. Then, asynchronous harvesting over the full database is triggered. This operation may take long time (minutes on rotating disk). After it finishes, no harvesting is normally performed again and subsequent completion requests use the harvested data cached in memory. Completion cache is updated after 24 hours. Note that this commit restores (different) completion functionality for users when the user used external command named "notmuch-addresses", i.e. the old default. The result will be that the user will use the new mechanism instead of this command. I believe that many users may not even recognize this because the new mechanism works the same as http://commonmeasure.org/~jkr/git/notmuch_addresses.git and perhaps also as other commands suggested at http://notmuchmail.org/emacstips/#address_completion. [This feature was significantly improved by David Bremner and Mark Walters]
2015-10-27 00:22:48 +01:00
emacs: add function to resend message to new recipients The new function notmuch-show-message-resend re-sends message to new recipients using #'message-resend. Recipients are read from minibuffer as a comma-separated string (with some keyboard support including tab completion). Final confirmation before sending is asked.
2016-05-07 21:03:11 +02:00
(defun notmuch-address-from-minibuffer (prompt)
(if (not notmuch-address-command)
(read-string prompt)
(let ((rmap (copy-keymap minibuffer-local-map))
(omap minibuffer-local-map))
;; Configure TAB to start completion when executing read-string.
;; "Original" minibuffer keymap is restored just before calling
;; notmuch-address-expand-name as it may also use minibuffer-local-map
;; (completing-read probably does not but if something else is used there).
(define-key rmap (kbd "TAB") (lambda ()
(interactive)
(let ((enable-recursive-minibuffers t)
(minibuffer-local-map omap))
(notmuch-address-expand-name))))
(let ((minibuffer-local-map rmap))
(read-string prompt)))))
emacs: make headings outline-minor-mode compatible `outline-minor-mode' treats comments that begin with three or more semicolons as headings. That makes it very convenient to navigate code and to show/hide parts of a file. Elips libraries typically have four top-level sections, e.g.: ;;; notmuch.el --- run notmuch within emacs... ;;; Commentary:... ;;; Code:... ;;; notmuch.el ends here In this package many libraries lack a "Commentary:" section, which is not optimal but okay for most libraries, except major entry points. Depending on how one chooses to look at it, the "... ends here" line is not really a heading that begins a section, because it should never have a "section" body (after all it marks eof). If the file is rather short, then I left "Code:" as the only section that contains code. Otherwise I split the file into multiple sibling sections. The "Code:" section continues to contain `require' and `declare-function' forms and other such "front matter". If and only if I have split the code into multiple sections anyway, then I also added an additional section named just "_" before the `provide' form and shortly before the "...end here" line. This section could also be called "Back matter", but I feel it would be distracting to be that explicit about it. (The IMO unnecessary but unfortunately still obligatory "... ends here" line is already distracting enough as far as I am concerned.) Before this commit some libraries already uses section headings, some of them consistently. When a library already had some headings, then this commit often sticks to that style, even at the cost inconsistent styling across all libraries. A very limited number of variable and function definitions have to be moved around because they would otherwise end up in sections they do not belong into. Sections, including but not limited to their heading, can and should be further improved in the future.
2021-01-10 15:00:46 +01:00
;;; _
emacs: add function to resend message to new recipients The new function notmuch-show-message-resend re-sends message to new recipients using #'message-resend. Recipients are read from minibuffer as a comma-separated string (with some keyboard support including tab completion). Final confirmation before sending is asked.
2016-05-07 21:03:11 +02:00
emacs: Add notmuch-address.el for address completion using notmuch A tool `notmuch-addresses' is required to produce addresses which match a query string. An example of a suitable script can be found in the git repository at http://jkr.acm.jhu.edu/git/notmuch_addresses.git There are no doubt others.
2010-04-22 11:03:43 +02:00
(provide 'notmuch-address)
emacs: Fix packaging Refer to (info "(elisp) Library Headers") for package conventions.
2016-04-13 09:58:47 +02:00
;;; notmuch-address.el ends here
Reference in a new issue Copy permalink