\begin{document}
% Adjust ../Makefile.in if you change the following line:
-\newcommand{\gnusversionname}{No Gnus v0.6}
+\newcommand{\gnusversionname}{No Gnus v0.5}
\newcommand{\gnuschaptername}{}
\newcommand{\gnussectionname}{}
luck.
@c Adjust ../Makefile.in if you change the following line:
-This manual corresponds to No Gnus v0.6.
+This manual corresponds to No Gnus v0.5.
@end ifinfo
* Mail Group Commands:: Some commands can only be used in mail groups.
* Various Summary Stuff:: What didn't fit anywhere else.
* Exiting the Summary Buffer:: Returning to the Group buffer,
- or reselecting the current group.
+ or reselecting the current group.
* Crosspost Handling:: How crossposted articles are dealt with.
* Duplicate Suppression:: An alternative when crosspost handling fails.
* Security:: Decrypt and Verify.
* X-Face:: Display a funky, teensy black-and-white image.
* Face:: Display a funkier, teensier colored image.
* Smileys:: Show all those happy faces the way they were
- meant to be shown.
+ meant to be shown.
* Picons:: How to display pictures of what you're reading.
* XVarious:: Other XEmacsy Gnusey variables.
hysterical raisins, even the mail back ends, where the true number of
unread messages might be available efficiently, use the same limited
interface. To remove this restriction from Gnus means that the back
-end interface has to be changed, which is not an easy job. If you
-want to work on this, please contact the Gnus mailing list.
+end interface has to be changed, which is not an easy job.
+
+The nnml backend (@pxref{Mail Spool}) has a feature called ``group
+compaction'' which circumvents this deficiency: the idea is to
+renumber all articles from 1, removing all gaps between numbers, hence
+getting a correct total count. Other backends may support this in the
+future. In order to keep your total article count relatively up to
+date, you might want to compact your groups (or even directly your
+server) from time to time. @xref{Misc Group Stuff}, @xref{Server Commands}.
@item y
Number of unread, unticked, non-dormant articles.
(cond (window-system
(setq custom-background-mode 'light)
(defface my-group-face-1
- '((t (:foreground "Red" :bold t))) "First group face")
+ '((t (:foreground "Red" :bold t))) "First group face")
(defface my-group-face-2
- '((t (:foreground "DarkSeaGreen4" :bold t)))
- "Second group face")
+ '((t (:foreground "DarkSeaGreen4" :bold t)))
+ "Second group face")
(defface my-group-face-3
- '((t (:foreground "Green4" :bold t))) "Third group face")
+ '((t (:foreground "Green4" :bold t))) "Third group face")
(defface my-group-face-4
- '((t (:foreground "SteelBlue" :bold t))) "Fourth group face")
+ '((t (:foreground "SteelBlue" :bold t))) "Fourth group face")
(defface my-group-face-5
- '((t (:foreground "Blue" :bold t))) "Fifth group face")))
+ '((t (:foreground "Blue" :bold t))) "Fifth group face")))
(setq gnus-group-highlight
'(((> unread 200) . my-group-face-1)
- ((and (< level 3) (zerop unread)) . my-group-face-2)
- ((< level 3) . my-group-face-3)
- ((zerop unread) . my-group-face-4)
- (t . my-group-face-5)))
+ ((and (< level 3) (zerop unread)) . my-group-face-2)
+ ((< level 3) . my-group-face-3)
+ ((zerop unread) . my-group-face-4)
+ (t . my-group-face-5)))
@end lisp
Also @pxref{Faces and Fonts}.
@example
if address "sender" "sieve-admin@@extundo.com" @{
- fileinto "INBOX.list.sieve";
+ fileinto "INBOX.list.sieve";
@}
@end example
@example
if address "sender" ["name@@one.org", "else@@two.org"] @{
- fileinto "INBOX.list.sieve";
+ fileinto "INBOX.list.sieve";
@}
@end example
@lisp
(setq gnus-parameters
'(("mail\\..*"
- (gnus-show-threads nil)
- (gnus-use-scoring nil)
- (gnus-summary-line-format
- "%U%R%z%I%(%[%d:%ub%-23,23f%]%) %s\n")
- (gcc-self . t)
- (display . all))
+ (gnus-show-threads nil)
+ (gnus-use-scoring nil)
+ (gnus-summary-line-format
+ "%U%R%z%I%(%[%d:%ub%-23,23f%]%) %s\n")
+ (gcc-self . t)
+ (display . all))
- ("^nnimap:\\(foo.bar\\)$"
- (to-group . "\\1"))
+ ("^nnimap:\\(foo.bar\\)$"
+ (to-group . "\\1"))
- ("mail\\.me"
- (gnus-use-scoring t))
+ ("mail\\.me"
+ (gnus-use-scoring t))
- ("list\\..*"
- (total-expire . t)
- (broken-reply-to . t))))
+ ("list\\..*"
+ (total-expire . t)
+ (broken-reply-to . t))))
@end lisp
String value of parameters will be subjected to regexp substitution, as
in question. The corresponding back end must have a request-post method
for this to work though.
+@item G z
+@kindex G z (Group)
+@findex gnus-group-compact-group
+
+Compact the group under point (@code{gnus-group-compact-group}).
+Currently implemented only in nnml (@pxref{Mail Spool}). This removes
+gaps between article numbers, hence getting a correct total article
+count.
+
@end table
Variables for the group buffer:
@example
* 0: mail.ding 19961002T012943
- 0: custom 19961002T012713
+ 0: custom 19961002T012713
@end example
As you can see, the date is displayed in compact ISO 8601 format. This
(defun gnus-user-format-function-d (headers)
(let ((time (gnus-group-timestamp gnus-tmp-group)))
(if time
- (format-time-string "%b %d %H:%M" time)
+ (format-time-string "%b %d %H:%M" time)
"")))
@end lisp
@example
if address "sender" "owner-ding@@hpc.uh.edu" @{
- fileinto "INBOX.ding";
- stop;
+ fileinto "INBOX.ding";
+ stop;
@}
@end example
* Mail Group Commands:: Some commands can only be used in mail groups.
* Various Summary Stuff:: What didn't fit anywhere else.
* Exiting the Summary Buffer:: Returning to the Group buffer,
- or reselecting the current group.
+ or reselecting the current group.
* Crosspost Handling:: How crossposted articles are dealt with.
* Duplicate Suppression:: An alternative when crosspost handling fails.
* Security:: Decrypt and Verify.
@lisp
(setq gnus-summary-show-article-charset-alist
'((1 . cn-gb-2312)
- (2 . big5)))
+ (2 . big5)))
@end lisp
then you can say @kbd{C-u 1 g} to get the same effect.
used for marking articles in such a way that other commands will
process these articles. For instance, if you process mark four
articles and then use the @kbd{*} command, Gnus will enter these four
-commands into the cache. For more information,
+articles into the cache. For more information,
@pxref{Process/Prefix}.
@table @kbd
(concat
"\\`\\[?\\("
(mapconcat
- 'identity
- '("looking"
- "wanted" "followup" "summary\\( of\\)?"
- "help" "query" "problem" "question"
- "answer" "reference" "announce"
- "How can I" "How to" "Comparison of"
- ;; ...
- )
- "\\|")
+ 'identity
+ '("looking"
+ "wanted" "followup" "summary\\( of\\)?"
+ "help" "query" "problem" "question"
+ "answer" "reference" "announce"
+ "How can I" "How to" "Comparison of"
+ ;; ...
+ )
+ "\\|")
"\\)\\s *\\("
(mapconcat 'identity
- '("for" "for reference" "with" "about")
- "\\|")
+ '("for" "for reference" "with" "about")
+ "\\|")
"\\)?\\]?:?[ \t]*"))
@end lisp
@lisp
(setq gnus-thread-hide-subtree
'(or gnus-article-unread-p
- gnus-article-unseen-p))
+ gnus-article-unseen-p))
@end lisp
(It's a pretty nonsensical example, since all unseen articles are also
(defun my-alter-message-id (header)
(let ((id (mail-header-id header)))
(when (string-match
- "\\(<[^<>@@]*\\)\\.?cygnus\\..*@@\\([^<>@@]*>\\)" id)
+ "\\(<[^<>@@]*\\)\\.?cygnus\\..*@@\\([^<>@@]*>\\)" id)
(mail-header-set-id
(concat (match-string 1 id) "@@" (match-string 2 id))
header))))
@lisp
(setq gnus-thread-sort-functions
'(gnus-thread-sort-by-number
- gnus-thread-sort-by-subject
- (not gnus-thread-sort-by-total-score)))
+ gnus-thread-sort-by-subject
+ (not gnus-thread-sort-by-total-score)))
@end lisp
The threads that have highest score will be displayed first in the
@lisp
(setq gnus-thread-sort-functions
'((not gnus-thread-sort-by-number)
- gnus-thread-sort-by-score))
+ gnus-thread-sort-by-score))
@end lisp
@vindex gnus-thread-score-function
@lisp
(setq gnus-article-sort-functions
'(gnus-article-sort-by-number
- gnus-article-sort-by-subject))
+ gnus-article-sort-by-subject))
@end lisp
You can define group specific sorting via @code{gnus-parameters},
"Return non-nil for short, unread articles."
(and (gnus-data-unread-p data)
(< (mail-header-lines (gnus-data-header data))
- 100)))
+ 100)))
(setq gnus-async-prefetch-article-p 'my-async-short-unread-p)
@end lisp
(setq gnus-split-methods
'((gnus-article-archive-name)
- (my-save-name)))
+ (my-save-name)))
@end lisp
@lisp
(list '(regexp1 command2)
- '(regexp2 command2)
- ...)
+ '(regexp2 command2)
+ ...)
@end lisp
@table @code
@lisp
(setq gnus-emphasis-alist
'(("_\\(\\w+\\)_" 0 1 gnus-emphasis-underline)
- ("\\*\\(\\w+\\)\\*" 0 1 gnus-emphasis-bold)))
+ ("\\*\\(\\w+\\)\\*" 0 1 gnus-emphasis-bold)))
@end lisp
@cindex slash
;; @r{increase @code{gnus-button-*-level} in some groups:}
(setq gnus-parameters
'(("\\<\\(emacs\\|gnus\\)\\>" (gnus-button-emacs-level 10))
- ("\\<unix\\>" (gnus-button-man-level 10))
- ("\\<tex\\>" (gnus-button-tex-level 10))))
+ ("\\<unix\\>" (gnus-button-man-level 10))
+ ("\\<tex\\>" (gnus-button-tex-level 10))))
@end lisp
@table @code
@lisp
(setq gnus-signature-separator
'("^-- $" ; @r{The standard}
- "^-- *$" ; @r{A common mangling}
- "^-------*$" ; @r{Many people just use a looong}
- ; @r{line of dashes. Shame!}
- "^ *--------*$" ; @r{Double-shame!}
- "^________*$" ; @r{Underscores are also popular}
- "^========*$")) ; @r{Pervert!}
+ "^-- *$" ; @r{A common mangling}
+ "^-------*$" ; @r{Many people just use a looong}
+ ; @r{line of dashes. Shame!}
+ "^ *--------*$" ; @r{Double-shame!}
+ "^________*$" ; @r{Underscores are also popular}
+ "^========*$")) ; @r{Pervert!}
@end lisp
The more permissive you are, the more likely it is that you'll get false
(with-temp-buffer
(insert (mm-get-part handle))
(write-region (point-min) (point-max)
- (read-file-name "Save jpeg to: ")))))
+ (read-file-name "Save jpeg to: ")))))
(setq gnus-article-mime-part-function
'my-save-all-jpeg-parts)
@end lisp
@lisp
(setq mm-file-name-rewrite-functions
'(mm-file-name-trim-whitespace
- mm-file-name-collapse-whitespace
- mm-file-name-replace-whitespace))
+ mm-file-name-collapse-whitespace
+ mm-file-name-replace-whitespace))
@end lisp
@noindent
@lisp
(put-charset-property 'cyrillic-iso8859-5
- 'preferred-coding-system 'koi8-r)
+ 'preferred-coding-system 'koi8-r)
@end lisp
This means that Russian will be encoded using @code{koi8-r} instead of
@lisp
(setq gnus-refer-article-method
'(current
- (nnweb "google" (nnweb-type google))))
+ (nnweb "google" (nnweb-type google))))
@end lisp
Most of the mail back ends support fetching by @code{Message-ID}, but
@lisp
(add-hook 'gnus-configure-windows-hook
- 'gnus-tree-perhaps-minimize)
+ 'gnus-tree-perhaps-minimize)
@end lisp
@item gnus-generate-tree-function
[odd] [Jan] [odd] (***) [Jor]
| | |--\
[Gun] [Eri] [Eri] [odd]
- |
- [Paa]
+ |
+ [Paa]
@end group
@end example
(gnus-add-configuration
'(article
(vertical 1.0
- (horizontal 0.25
- (summary 0.75 point)
- (tree 1.0))
- (article 1.0))))
+ (horizontal 0.25
+ (summary 0.75 point)
+ (tree 1.0))
+ (article 1.0))))
@end lisp
@xref{Window Layout}.
@lisp
(setq gnus-move-split-methods
'(("^From:.*Lars Magne" "nnml:junk")
- ("^Subject:.*gnus" "nnfolder:important")
- (".*" "nnml:misc")))
+ ("^Subject:.*gnus" "nnfolder:important")
+ (".*" "nnml:misc")))
@end lisp
@lisp
(setq gnus-newsgroup-variables
'(message-use-followup-to
- (gnus-visible-headers .
+ (gnus-visible-headers .
"^From:\\|^Newsgroups:\\|^Subject:\\|^Date:\\|^To:")))
@end lisp
@lisp
(setq mail-source-primary-source
'(pop :server "pop3.mail.server"
- :password "secret"))
+ :password "secret"))
@end lisp
@noindent
@lisp
(add-hook 'message-send-mail-hook
- (lambda ()
- (let ((mail-source-primary-source
- '(pop :server "pop3.mail.server"
- :password "secret")))
- (mail-source-touch-pop))))
+ (lambda ()
+ (let ((mail-source-primary-source
+ '(pop :server "pop3.mail.server"
+ :password "secret")))
+ (mail-source-touch-pop))))
@end lisp
@node Mail and Post
@lisp
(add-hook 'gnus-select-group-hook
- (lambda ()
- (cond
- ((string-match
- "^de\\." (gnus-group-real-name gnus-newsgroup-name))
- (ispell-change-dictionary "deutsch"))
- (t
- (ispell-change-dictionary "english")))))
+ (lambda ()
+ (cond
+ ((string-match
+ "^de\\." (gnus-group-real-name gnus-newsgroup-name))
+ (ispell-change-dictionary "deutsch"))
+ (t
+ (ispell-change-dictionary "english")))))
@end lisp
Modify to suit your needs.
@lisp
(nnfolder "archive"
- (nnfolder-directory "~/Mail/archive")
- (nnfolder-active-file "~/Mail/archive/active")
- (nnfolder-get-new-mail nil)
- (nnfolder-inhibit-expiry t))
+ (nnfolder-directory "~/Mail/archive")
+ (nnfolder-active-file "~/Mail/archive/active")
+ (nnfolder-get-new-mail nil)
+ (nnfolder-inhibit-expiry t))
@end lisp
You can, however, use any mail select method (@code{nnml},
@lisp
(setq gnus-message-archive-method
'(nnfolder "archive"
- (nnfolder-inhibit-expiry t)
- (nnfolder-active-file "~/News/sent-mail/active")
- (nnfolder-directory "~/News/sent-mail/")))
+ (nnfolder-inhibit-expiry t)
+ (nnfolder-active-file "~/News/sent-mail/active")
+ (nnfolder-directory "~/News/sent-mail/")))
@end lisp
@vindex gnus-message-archive-group
@lisp
(setq gnus-message-archive-group
'(("^alt" "sent-to-alt")
- ("mail" "sent-to-mail")
- (".*" "sent-to-misc")))
+ ("mail" "sent-to-mail")
+ (".*" "sent-to-misc")))
@end lisp
More complex stuff:
@lisp
(setq gnus-message-archive-group
'((if (message-news-p)
- "misc-news"
- "misc-mail")))
+ "misc-news"
+ "misc-mail")))
@end lisp
How about storing all news messages in one file, but storing all mail
@lisp
(setq gnus-message-archive-group
'((if (message-news-p)
- "misc-news"
- (concat "mail." (format-time-string "%Y-%m")))))
+ "misc-news"
+ (concat "mail." (format-time-string "%Y-%m")))))
@end lisp
@c (XEmacs 19.13 doesn't have @code{format-time-string}, so you'll have to
@item @code{body}
@end itemize
+Note that the @code{signature-file} attribute honors the variable
+@code{message-signature-directory}.
+
The attribute name can also be a string or a symbol. In that case,
this will be used as a header name, and the value will be inserted in
the headers of the article; if the value is @code{nil}, the header
@lisp
(setq gnus-posting-styles
'((".*"
- (signature-file "~/.signature")
- (name "User Name")
- (x-face-file "~/.xface")
- (x-url (getenv "WWW_HOME"))
- (organization "People's Front Against MWM"))
- ("^rec.humor"
- (signature my-funny-signature-randomizer))
- ((equal (system-name) "gnarly") ;; @r{A form}
- (signature my-quote-randomizer))
- (message-news-p ;; @r{A function symbol}
- (signature my-news-signature))
- (window-system ;; @r{A value symbol}
- ("X-Window-System" (format "%s" window-system)))
- ;; @r{If I'm replying to Larsi, set the Organization header.}
- ((header "from" "larsi.*org")
- (Organization "Somewhere, Inc."))
- ((posting-from-work-p) ;; @r{A user defined function}
- (signature-file "~/.work-signature")
- (address "user@@bar.foo")
- (body "You are fired.\n\nSincerely, your boss.")
- (organization "Important Work, Inc"))
- ("nnml:.*"
- (From (save-excursion
- (set-buffer gnus-article-buffer)
- (message-fetch-field "to"))))
- ("^nn.+:"
- (signature-file "~/.mail-signature"))))
+ (signature-file "~/.signature")
+ (name "User Name")
+ (x-face-file "~/.xface")
+ (x-url (getenv "WWW_HOME"))
+ (organization "People's Front Against MWM"))
+ ("^rec.humor"
+ (signature my-funny-signature-randomizer))
+ ((equal (system-name) "gnarly") ;; @r{A form}
+ (signature my-quote-randomizer))
+ (message-news-p ;; @r{A function symbol}
+ (signature my-news-signature))
+ (window-system ;; @r{A value symbol}
+ ("X-Window-System" (format "%s" window-system)))
+ ;; @r{If I'm replying to Larsi, set the Organization header.}
+ ((header "from" "larsi.*org")
+ (Organization "Somewhere, Inc."))
+ ((posting-from-work-p) ;; @r{A user defined function}
+ (signature-file "~/.work-signature")
+ (address "user@@bar.foo")
+ (body "You are fired.\n\nSincerely, your boss.")
+ (organization "Important Work, Inc"))
+ ("nnml:.*"
+ (From (save-excursion
+ (set-buffer gnus-article-buffer)
+ (message-fetch-field "to"))))
+ ("^nn.+:"
+ (signature-file "~/.mail-signature"))))
@end lisp
The @samp{nnml:.*} rule means that you use the @code{To} address as the
(@code{gnus-server-regenerate-server}). This can be useful if you have
a mail back end that has gotten out of sync.
+@item z
+@kindex z (Server)
+@findex gnus-server-compact-server
+
+Compact all groups in the server under point
+(@code{gnus-server-compact-server}). Currently implemented only in
+nnml (@pxref{Mail Spool}). This removes gaps between article numbers,
+hence getting a correct total article count.
+
@end table
@lisp
(setq gnus-select-method
'(nntp "indirect"
- (nntp-address "news.server.example")
- (nntp-via-user-name "intermediate_user_name")
- (nntp-via-address "intermediate.host.example")
- (nntp-via-rlogin-command "ssh")
- (nntp-end-of-line "\n")
- (nntp-via-rlogin-command-switches ("-C" "-t" "-e" "none"))
- (nntp-open-connection-function nntp-open-via-rlogin-and-telnet)))
+ (nntp-address "news.server.example")
+ (nntp-via-user-name "intermediate_user_name")
+ (nntp-via-address "intermediate.host.example")
+ (nntp-via-rlogin-command "ssh")
+ (nntp-end-of-line "\n")
+ (nntp-via-rlogin-command-switches ("-C" "-t" "-e" "none"))
+ (nntp-open-connection-function nntp-open-via-rlogin-and-telnet)))
@end lisp
If you're behind a firewall, but have direct access to the outside world
@lisp
(nnml "cache"
- (nnml-directory "~/News/cache/")
- (nnml-active-file "~/News/cache/active"))
+ (nnml-directory "~/News/cache/")
+ (nnml-active-file "~/News/cache/active"))
@end lisp
Type @kbd{C-c C-c} to return to the server buffer. If you now press
@lisp
'(("nntpd 1\\.5\\.11t"
(remove-hook 'nntp-server-opened-hook
- 'nntp-send-mode-reader)))
+ 'nntp-send-mode-reader)))
@end lisp
This ensures that Gnus doesn't send the @code{MODE READER} command to
@lisp
(setq nnmail-split-methods
'(("junk" "^From:.*Lars Ingebrigtsen")
- ("crazy" "^Subject:.*die\\|^Organization:.*flabby")
- ("other" "")))
+ ("crazy" "^Subject:.*die\\|^Organization:.*flabby")
+ ("other" "")))
@end lisp
This will result in three new @code{nnml} mail groups being created:
@vindex nnmail-mail-splitting-charset
@vindex nnmail-mail-splitting-decodes
-By default the splitting codes @acronym{MIME} decodes headers so you
+By default, splitting @acronym{MIME}-decodes headers so you
can match on non-@acronym{ASCII} strings. The
@code{nnmail-mail-splitting-charset} variable specifies the default
charset for decoding. The behavior can be turned off completely by
rm -f $TMP; $MOVEMAIL $MAIL $TMP >/dev/null && cat $TMP
@end example
-Alter this script to fit find the @samp{movemail} you want to use.
+Alter this script to fit the @samp{movemail} and temporary
+file you want to use.
@item directory
@lisp
(directory :path "/home/user-name/procmail-dir/"
- :suffix ".prcml")
+ :suffix ".prcml")
@end lisp
@item pop
@lisp
(maildir :path "/home/user-name/Maildir/"
- :subdirs ("cur" "new"))
+ :subdirs ("cur" "new"))
@end lisp
@lisp
(maildir :path "/user@@remotehost.org:~/Maildir/"
- :subdirs ("new"))
+ :subdirs ("new"))
@end lisp
@item imap
@lisp
(webmail :subtype 'hotmail
- :user "user-name"
- :password "secret")
+ :user "user-name"
+ :password "secret")
@end lisp
@end table
@lisp
(setq mail-sources
'((directory :path "/home/pavel/.Spool/"
- :suffix ""
- :plugged t)))
+ :suffix ""
+ :plugged t)))
@end lisp
Gnus will then fetch your mail even when you are unplugged. This is
@lisp
(setq mail-sources '((pop :user "jrl"
- :server "pophost" :function fetchfunc)))
+ :server "pophost" :function fetchfunc)))
@end lisp
While the function @code{fetchfunc} is executing, the symbol @code{user}
@lisp
(setq mail-sources
'((file)
- (pop :server "pop3.mail.server"
- :password "secret")))
+ (pop :server "pop3.mail.server"
+ :password "secret")))
@end lisp
Or, if you don't want to use any of the keyword defaults:
@lisp
(setq mail-sources
'((file :path "/var/spool/mail/user-name")
- (pop :server "pop3.mail.server"
- :user "user-name"
- :port "pop3"
- :password "secret")))
+ (pop :server "pop3.mail.server"
+ :user "user-name"
+ :port "pop3"
+ :password "secret")))
@end lisp
@lisp
(add-hook 'nnmail-pre-get-new-mail-hook
- (lambda () (set-default-file-modes 511)))
+ (lambda () (set-default-file-modes 511)))
(add-hook 'nnmail-post-get-new-mail-hook
- (lambda () (set-default-file-modes 551)))
+ (lambda () (set-default-file-modes 551)))
@end lisp
@item nnmail-use-long-file-names
;; @r{the ordinary groups. Warnings are put in a separate group}
;; @r{from real errors.}
(| ("from" mail (| ("subject" "warn.*" "mail.warning")
- "mail.misc"))
+ "mail.misc"))
;; @r{Non-error messages are crossposted to all relevant}
;; @r{groups, but we don't crosspost between the group for the}
;; @r{(ding) list and the group for other (ding) related mail.}
(& (| (any "ding@@ifi\\.uio\\.no" "ding.list")
- ("subject" "ding" "ding.misc"))
+ ("subject" "ding" "ding.misc"))
;; @r{Other mailing lists@dots{}}
(any "procmail@@informatik\\.rwth-aachen\\.de" "procmail.list")
(any "SmartList@@informatik\\.rwth-aachen\\.de" "SmartList.list")
(widen)
(goto-char (point-min))
(when (re-search-forward "Some.*string" nil t)
- "string.group"))))
+ "string.group"))))
@end lisp
The buffer is narrowed to the message in question when @var{function}
nnmail-cache-accepted-message-ids t
nnmail-split-fancy
'(| (: nnmail-split-fancy-with-parent)
- ;; @r{other splits go here}
- ))
+ ;; @r{other splits go here}
+ ))
@end lisp
This feature works as follows: when @code{nnmail-treat-duplicates} is
@lisp
(| (& (any "\\(bar@@femail\\.com\\|.*@@femail\\.com\\)" "mail.bar")
(any "\\(foo@@nowhere\\.gov\\|foo@@localhost\\|foo-redist@@home\\)"
- - "bugs-foo" - "rambling-foo" "mail.foo"))
+ - "bugs-foo" - "rambling-foo" "mail.foo"))
"mail.others")
@end lisp
@vindex gnus-mark-article-hook
@lisp
(remove-hook 'gnus-mark-article-hook
- 'gnus-summary-mark-read-and-unread-as-read)
+ 'gnus-summary-mark-read-and-unread-as-read)
(add-hook 'gnus-mark-article-hook 'gnus-summary-mark-unread-as-read)
@end lisp
(setq nnmail-expiry-wait-function
(lambda (group)
(cond ((string= group "mail.private")
- 31)
- ((string= group "mail.junk")
- 1)
- ((string= group "important")
- 'never)
- (t
- 6))))
+ 31)
+ ((string= group "mail.junk")
+ 1)
+ ((string= group "important")
+ 'never)
+ (t
+ 6))))
@end lisp
The group names this function is fed are ``unadorned'' group
(setq nnmail-expiry-target 'nnmail-fancy-expiry-target
nnmail-fancy-expiry-targets
'((to-from "boss" "nnfolder:Work")
- ("subject" "IMPORTANT" "nnfolder:IMPORTANT.%Y.%b")
- ("from" ".*" "nnfolder:Archive-%Y")))
+ ("subject" "IMPORTANT" "nnfolder:IMPORTANT.%Y.%b")
+ ("from" ".*" "nnfolder:Archive-%Y")))
@end lisp
With this setup, any mail that has @code{IMPORTANT} in its Subject
@lisp
(setq nnmail-split-fancy
'(| ;; @r{Messages duplicates go to a separate group.}
- ("gnus-warning" "duplicat\\(e\\|ion\\) of message" "duplicate")
- ;; @r{Message from daemons, postmaster, and the like to another.}
- (any mail "mail.misc")
- ;; @r{Other rules.}
- [...] ))
+ ("gnus-warning" "duplicat\\(e\\|ion\\) of message" "duplicate")
+ ;; @r{Message from daemons, postmaster, and the like to another.}
+ (any mail "mail.misc")
+ ;; @r{Other rules.}
+ [...] ))
@end lisp
@noindent
Or something like:
@lisp
(setq nnmail-split-methods
'(("duplicates" "^Gnus-Warning:.*duplicate")
- ;; @r{Other rules.}
- [...]))
+ ;; @r{Other rules.}
+ [...]))
@end lisp
Here's a neat feature: If you know that the recipient reads her mail
(defun gnus-user-format-function-X (header)
(let ((descr
- (assq nnrss-description-field (mail-header-extra header))))
+ (assq nnrss-description-field (mail-header-extra header))))
(if descr (concat "\n\t" (cdr descr)) "")))
@end lisp
(defun browse-nnrss-url( arg )
(interactive "p")
(let ((url (assq nnrss-url-field
- (mail-header-extra
- (gnus-data-header
- (assq (gnus-summary-article-number)
- gnus-newsgroup-data))))))
+ (mail-header-extra
+ (gnus-data-header
+ (assq (gnus-summary-article-number)
+ gnus-newsgroup-data))))))
(if url
- (progn
- (browse-url (cdr url))
- (gnus-summary-mark-as-read-forward 1))
+ (progn
+ (browse-url (cdr url))
+ (gnus-summary-mark-as-read-forward 1))
(gnus-summary-scroll-up arg))))
(eval-after-load "gnus"
(defun w3-fetch (&optional url target)
(interactive (list (w3-read-url-with-default)))
(if (eq major-mode 'gnus-article-mode)
- (browse-url url)
- (w3-fetch-orig url target)))))
+ (browse-url url)
+ (w3-fetch-orig url target)))))
@end lisp
Put that in your @file{.emacs} file, and hitting links in W3-rendered
@lisp
(setq gnus-secondary-select-methods
'((nnimap "simpleserver") ; @r{no special configuration}
- ; @r{perhaps a ssh port forwarded server:}
- (nnimap "dolk"
- (nnimap-address "localhost")
- (nnimap-server-port 1430))
- ; @r{a UW server running on localhost}
- (nnimap "barbar"
- (nnimap-server-port 143)
- (nnimap-address "localhost")
- (nnimap-list-pattern ("INBOX" "mail/*")))
- ; @r{anonymous public cyrus server:}
- (nnimap "cyrus.andrew.cmu.edu"
- (nnimap-authenticator anonymous)
- (nnimap-list-pattern "archive.*")
- (nnimap-stream network))
- ; @r{a ssl server on a non-standard port:}
- (nnimap "vic20"
- (nnimap-address "vic20.somewhere.com")
- (nnimap-server-port 9930)
- (nnimap-stream ssl))))
+ ; @r{perhaps a ssh port forwarded server:}
+ (nnimap "dolk"
+ (nnimap-address "localhost")
+ (nnimap-server-port 1430))
+ ; @r{a UW server running on localhost}
+ (nnimap "barbar"
+ (nnimap-server-port 143)
+ (nnimap-address "localhost")
+ (nnimap-list-pattern ("INBOX" "mail/*")))
+ ; @r{anonymous public cyrus server:}
+ (nnimap "cyrus.andrew.cmu.edu"
+ (nnimap-authenticator anonymous)
+ (nnimap-list-pattern "archive.*")
+ (nnimap-stream network))
+ ; @r{a ssl server on a non-standard port:}
+ (nnimap "vic20"
+ (nnimap-address "vic20.somewhere.com")
+ (nnimap-server-port 9930)
+ (nnimap-stream ssl))))
@end lisp
After defining the new server, you can subscribe to groups on the
@lisp
(nnimap "mail.server.com"
- (nnimap-server-port 4711))
+ (nnimap-server-port 4711))
@end lisp
@item nnimap-list-pattern
@lisp
(nnimap "mail.server.com"
- (nnimap-list-pattern ("INBOX" "Mail/*" "alt.sex.*"
- ("~friend/Mail/" . "list/*"))))
+ (nnimap-list-pattern ("INBOX" "Mail/*" "alt.sex.*"
+ ("~friend/Mail/" . "list/*"))))
@end lisp
@item nnimap-stream
@lisp
(nnimap "mail.server.com"
- (nnimap-stream ssl))
+ (nnimap-stream ssl))
@end lisp
Please note that the value of @code{nnimap-stream} is a symbol!
@lisp
(nnimap "mail.server.com"
- (nnimap-authenticator anonymous))
+ (nnimap-authenticator anonymous))
@end lisp
Please note that the value of @code{nnimap-authenticator} is a symbol!
@lisp
(setcdr (assq 'dormant nnimap-mark-to-flag-alist)
- (format "gnus-dormant-%s" (user-login-name)))
+ (format "gnus-dormant-%s" (user-login-name)))
(setcdr (assq 'dormant nnimap-mark-to-predicate-alist)
- (format "KEYWORD gnus-dormant-%s" (user-login-name)))
+ (format "KEYWORD gnus-dormant-%s" (user-login-name)))
@end lisp
In this case, you would not want the per-user dormant flag showing up
@lisp
(setq nnimap-split-rule
'(("INBOX.nnimap"
- "^Sender: owner-nnimap@@vic20.globalcom.se")
- ("INBOX.junk" "^Subject:.*MAKE MONEY")
- ("INBOX.private" "")))
+ "^Sender: owner-nnimap@@vic20.globalcom.se")
+ ("INBOX.junk" "^Subject:.*MAKE MONEY")
+ ("INBOX.private" "")))
@end lisp
This will put all articles from the nnimap mailing list into mailbox
@lisp
(setq nnimap-split-rule
'(("my1server" (".*" (("ding" "ding@@gnus.org")
- ("junk" "From:.*Simon"))))
- ("my2server" ("INBOX" nnimap-split-fancy))
- ("my[34]server" (".*" (("private" "To:.*Simon")
- ("junk" my-junk-func))))))
+ ("junk" "From:.*Simon"))))
+ ("my2server" ("INBOX" nnimap-split-fancy))
+ ("my[34]server" (".*" (("private" "To:.*Simon")
+ ("junk" my-junk-func))))))
@end lisp
The virtual server name is in fact a regexp, so that the same rules
@lisp
(setq gnus-post-method
'(nngateway
- "mail2news@@replay.com"
- (nngateway-header-transformation
- nngateway-mail2news-header-transformation)))
+ "mail2news@@replay.com"
+ (nngateway-header-transformation
+ nngateway-mail2news-header-transformation)))
@end lisp
So, to use this, simply say something like:
(require 'gnus-agent)
(setq gnus-category-predicate-alist
(append gnus-category-predicate-alist
- '((old . my-article-old-p))))
+ '((old . my-article-old-p))))
@end lisp
and simply specify your predicate as:
@lisp
(agent-score ("from"
- ("Lars Ingebrigtsen" 1000000 nil s))
- ("lines"
- (500 -100 nil <)))
+ ("Lars Ingebrigtsen" 1000000 nil s))
+ ("lines"
+ (500 -100 nil <)))
@end lisp
Again, note the omission of the outermost parenthesis here.
(files "/hom/larsi/News/gnu.SCORE")
(exclude-files "all.SCORE")
(local (gnus-newsgroup-auto-expire t)
- (gnus-summary-make-false-root empty))
+ (gnus-summary-make-false-root empty))
(eval (ding)))
@end lisp
You can do this with the following two score file entries:
@example
- (orphan -500)
- (mark-and-expunge -100)
+ (orphan -500)
+ (mark-and-expunge -100)
@end example
When you enter the group the first time, you will only see the new
@lisp
(setq gnus-default-adaptive-word-score-alist
`((,gnus-read-mark . 30)
- (,gnus-catchup-mark . -10)
- (,gnus-killed-mark . -20)
- (,gnus-del-mark . -15)))
+ (,gnus-catchup-mark . -10)
+ (,gnus-killed-mark . -20)
+ (,gnus-del-mark . -15)))
@end lisp
This is the default value. If you have adaption on words enabled, every
(setq gnus-home-score-file
;; @r{All groups that match the regexp @code{"\\.emacs"}}
'(("\\.emacs" "emacs.SCORE")
- ;; @r{All the comp groups in one score file}
- ("^comp" "comp.SCORE")))
+ ;; @r{All the comp groups in one score file}
+ ("^comp" "comp.SCORE")))
@end lisp
@vindex gnus-home-adapt-file
@lisp
(setq gnus-global-score-files
'("/ftp@@ftp.gnus.org:/pub/larsi/ding/score/soc.motss.SCORE"
- "/ftp@@ftp.some-where:/pub/score/"))
+ "/ftp@@ftp.some-where:/pub/score/"))
@end lisp
@findex gnus-score-search-global-directories
"Decay SCORE according to `gnus-score-decay-constant'
and `gnus-score-decay-scale'."
(let ((n (- score
- (* (if (< score 0) -1 1)
- (min (abs score)
- (max gnus-score-decay-constant
- (* (abs score)
- gnus-score-decay-scale)))))))
+ (* (if (< score 0) -1 1)
+ (min (abs score)
+ (max gnus-score-decay-constant
+ (* (abs score)
+ gnus-score-decay-scale)))))))
(if (and (featurep 'xemacs)
- ;; XEmacs' floor can handle only the floating point
- ;; number below the half of the maximum integer.
- (> (abs n) (lsh -1 -2)))
- (string-to-number
- (car (split-string (number-to-string n) "\\.")))
+ ;; XEmacs' floor can handle only the floating point
+ ;; number below the half of the maximum integer.
+ (> (abs n) (lsh -1 -2)))
+ (string-to-number
+ (car (split-string (number-to-string n) "\\.")))
(floor n))))
@end lisp
@lisp
((group (vertical 1.0 (group 1.0 point)
- (if gnus-carpal (group-carpal 4))))
+ (if gnus-carpal (group-carpal 4))))
(article (vertical 1.0 (summary 0.25 point)
- (article 1.0))))
+ (article 1.0))))
@end lisp
This is an alist. The @dfn{key} is a symbol that names some action or
@lisp
(article (vertical 1.0 (summary 0.25 point)
- (article 1.0)))
+ (article 1.0)))
@end lisp
This @dfn{split} says that the summary buffer should occupy 25% of upper
@lisp
(article (vertical 1.0 (group 4)
- (summary 0.25 point)
- (if gnus-carpal (summary-carpal 4))
- (article 1.0)))
+ (summary 0.25 point)
+ (if gnus-carpal (summary-carpal 4))
+ (article 1.0)))
@end lisp
If the size spec is an integer instead of a floating point number,
@lisp
(article (horizontal 1.0
- (vertical 0.5
- (group 1.0)
- (gnus-carpal 4))
- (vertical 1.0
- (summary 0.25 point)
- (summary-carpal 4)
- (article 1.0))))
+ (vertical 0.5
+ (group 1.0)
+ (gnus-carpal 4))
+ (vertical 1.0
+ (summary 0.25 point)
+ (summary-carpal 4)
+ (article 1.0))))
@end lisp
Whoops. Two buffers with the mystery 100% tag. And what's that
(vertical 1.0
(article 1.0)
(horizontal 4
- (group 1.0)
- (article 10)))))
+ (group 1.0)
+ (article 10)))))
@end lisp
You might want to have several frames as well. No prob---just use the
@lisp
(gnus-configure-frame
'(frame 1.0
- (vertical 1.0
- (summary 0.25 point frame-focus)
- (article 1.0))
- (vertical ((height . 5) (width . 15)
- (user-position . t)
- (left . -1) (top . 1))
- (picon 1.0))))
+ (vertical 1.0
+ (summary 0.25 point frame-focus)
+ (article 1.0))
+ (vertical ((height . 5) (width . 15)
+ (user-position . t)
+ (left . -1) (top . 1))
+ (picon 1.0))))
@end lisp
@lisp
(message (horizontal 1.0
- (vertical 1.0 (message 1.0 point))
- (vertical 0.24
- (if (buffer-live-p gnus-summary-buffer)
- '(summary 0.5))
- (group 1.0))))
+ (vertical 1.0 (message 1.0 point))
+ (vertical 0.24
+ (if (buffer-live-p gnus-summary-buffer)
+ '(summary 0.5))
+ (group 1.0))))
@end lisp
One common desire for a multiple frame split is to have a separate frame
@lisp
(message
(frame 1.0
- (if (not (buffer-live-p gnus-summary-buffer))
- (car (cdr (assoc 'group gnus-buffer-configuration)))
- (car (cdr (assoc 'summary gnus-buffer-configuration))))
- (vertical ((user-position . t) (top . 1) (left . 1)
- (name . "Message"))
- (message 1.0 point))))
+ (if (not (buffer-live-p gnus-summary-buffer))
+ (car (cdr (assoc 'group gnus-buffer-configuration)))
+ (car (cdr (assoc 'summary gnus-buffer-configuration))))
+ (vertical ((user-position . t) (top . 1) (left . 1)
+ (name . "Message"))
+ (message 1.0 point))))
@end lisp
@findex gnus-add-configuration
@lisp
(gnus-add-configuration
'(article (vertical 1.0
- (group 4)
- (summary .25 point)
- (article 1.0))))
+ (group 4)
+ (summary .25 point)
+ (article 1.0))))
@end lisp
You'd typically stick these @code{gnus-add-configuration} calls in your
(gnus-add-configuration
'(article
(horizontal 1.0
- (vertical 25 (group 1.0))
- (vertical 1.0
- (summary 0.16 point)
- (article 1.0)))))
+ (vertical 25 (group 1.0))
+ (vertical 1.0
+ (summary 0.16 point)
+ (article 1.0)))))
(gnus-add-configuration
'(summary
(horizontal 1.0
- (vertical 25 (group 1.0))
- (vertical 1.0 (summary 1.0 point)))))
+ (vertical 25 (group 1.0))
+ (vertical 1.0 (summary 1.0 point)))))
@end lisp
@end itemize
@c Hook written by Francesco Potorti` <pot@cnuce.cnr.it>
@lisp
(add-hook 'display-time-hook
- (lambda () (setq gnus-mode-non-string-length
- (+ 21
- (if line-number-mode 5 0)
- (if column-number-mode 4 0)
- (length display-time-string)))))
+ (lambda () (setq gnus-mode-non-string-length
+ (+ 21
+ (if line-number-mode 5 0)
+ (if column-number-mode 4 0)
+ (length display-time-string)))))
@end lisp
If this variable is @code{nil} (which is the default), the mode line
;; Specify the altitude of Face and X-Face images in the From header.
(setq gnus-face-properties-alist
'((pbm . (:face gnus-x-face :ascent 80))
- (png . (:ascent 80))))
+ (png . (:ascent 80))))
;; Show Face and X-Face images as pressed buttons.
(setq gnus-face-properties-alist
'((pbm . (:face gnus-x-face :relief -2))
- (png . (:relief -2))))
+ (png . (:relief -2))))
@end lisp
@pxref{Image Descriptors, ,Image Descriptors, elisp, The Emacs Lisp
@lisp
(setq message-required-news-headers
(nconc message-required-news-headers
- (list '(X-Face . gnus-random-x-face))))
+ (list '(X-Face . gnus-random-x-face))))
@end lisp
Using the last function would be something like this:
@lisp
(setq message-required-news-headers
(nconc message-required-news-headers
- (list '(X-Face . (lambda ()
- (gnus-x-face-from-file
- "~/My-face.gif"))))))
+ (list '(X-Face . (lambda ()
+ (gnus-x-face-from-file
+ "~/My-face.gif"))))))
@end lisp
@lisp
(setq message-required-news-headers
(nconc message-required-news-headers
- (list '(Face . (lambda ()
- (gnus-face-from-file "~/face.jpg"))))))
+ (list '(Face . (lambda ()
+ (gnus-face-from-file "~/face.jpg"))))))
@end lisp
(...
(to "larsi@@trym.ifi.uio.no"
(| ("subject" "re:.*" "misc")
- ("references" ".*@@.*" "misc")
- "spam"))
+ ("references" ".*@@.*" "misc")
+ "spam"))
...)
@end lisp
@lisp
(setq mail-sources
'((file :prescript "formail -bs spamassassin < /var/mail/%u")
- (pop :user "jrl"
- :server "pophost"
- :postscript
- "mv %t /tmp/foo; formail -bs spamc < /tmp/foo > %t")))
+ (pop :user "jrl"
+ :server "pophost"
+ :postscript
+ "mv %t /tmp/foo; formail -bs spamc < /tmp/foo > %t")))
@end lisp
Once you manage to process your incoming spool somehow, thus making
@lisp
(setq nnmail-split-methods '(("spam" "^X-Spam-Flag: YES")
- ...))
+ ...))
@end lisp
Or using fancy split methods (@pxref{Fancy Mail Splitting}):
@lisp
(setq nnmail-split-methods 'nnmail-split-fancy
nnmail-split-fancy '(| ("X-Spam-Flag" "YES" "spam")
- ...))
+ ...))
@end lisp
Some people might not like the idea of piping the mail through various
@lisp
(setq nnmail-split-fancy '(| (: kevin-spamassassin)
- ...))
+ ...))
(defun kevin-spamassassin ()
(save-excursion
(save-restriction
(widen)
(if (eq 1 (call-process-region (point-min) (point-max)
- "spamc" nil nil nil "-c"))
- "spam"))))
+ "spamc" nil nil nil "-c"))
+ "spam"))))
@end lisp
Note that with the nnimap back end, message bodies will not be
@example
nnimap-split-fancy '(|
- (any "ding" "ding")
- (: spam-split)
- ;; @r{default mailbox}
- "mail")
+ (any "ding" "ding")
+ (: spam-split)
+ ;; @r{default mailbox}
+ "mail")
@end example
@noindent
@example
nnimap-split-fancy
'(|
- ;; @r{spam detected by @code{spam-use-regex-headers} goes to @samp{regex-spam}}
- (: spam-split "regex-spam" 'spam-use-regex-headers)
- (any "ding" "ding")
- ;; @r{all other spam detected by spam-split goes to @code{spam-split-group}}
- (: spam-split)
- ;; @r{default mailbox}
- "mail")
+ ;; @r{spam detected by @code{spam-use-regex-headers} goes to @samp{regex-spam}}
+ (: spam-split "regex-spam" 'spam-use-regex-headers)
+ (any "ding" "ding")
+ ;; @r{all other spam detected by spam-split goes to @code{spam-split-group}}
+ (: spam-split)
+ ;; @r{default mailbox}
+ "mail")
@end example
@noindent
nnimap-split-rule 'nnimap-split-fancy
;; @r{understand what this does before you copy it to your own setup!}
nnimap-split-fancy '(|
- ;; @r{trace references to parents and put in their group}
- (: gnus-registry-split-fancy-with-parent)
- ;; @r{this will catch server-side SpamAssassin tags}
- (: spam-split 'spam-use-regex-headers)
- (any "ding" "ding")
- ;; @r{note that spam by default will go to @samp{spam}}
- (: spam-split)
- ;; @r{default mailbox}
- "mail"))
+ ;; @r{trace references to parents and put in their group}
+ (: gnus-registry-split-fancy-with-parent)
+ ;; @r{this will catch server-side SpamAssassin tags}
+ (: spam-split 'spam-use-regex-headers)
+ (any "ding" "ding")
+ ;; @r{note that spam by default will go to @samp{spam}}
+ (: spam-split)
+ ;; @r{default mailbox}
+ "mail"))
;; @r{my parameters, set with @kbd{G p}}
;; @r{also to my @samp{nnimap+mail.lifelogs.com:trainham} folder for training}
(ham-process-destination "nnimap+mail.lifelogs.com:mail"
- "nnimap+mail.lifelogs.com:trainham")
+ "nnimap+mail.lifelogs.com:trainham")
;; @r{in this group, only @samp{!} marks are ham}
(ham-marks
(gnus-ticked-mark))
@example
((spam-contents gnus-group-spam-classification-ham)
(spam-process ((ham spam-use-spamoracle)
- (spam spam-use-spamoracle))))
+ (spam spam-use-spamoracle))))
@end example
For this group the @code{spam-use-spamoracle} is installed for both
ham and spam processing. If the group contains spam message
@lisp
(setq nnmail-split-fancy
`(| (: spam-stat-split-fancy)
- "mail.misc"))
+ "mail.misc"))
@end lisp
@defvar spam-stat-split-fancy-spam-group
@lisp
(setq nnmail-split-fancy
`(| ("Subject" "\\bspam-stat\\b" "mail.emacs")
- (: spam-stat-split-fancy)
- "mail.misc"))
+ (: spam-stat-split-fancy)
+ "mail.misc"))
@end lisp
If you want to filter for spam first, then you must be careful when
@lisp
(setq nnmail-split-fancy
`(| (: spam-stat-split-fancy)
- ("Subject" "\\bspam-stat\\b" "mail.emacs")
- "mail.misc"))
+ ("Subject" "\\bspam-stat\\b" "mail.emacs")
+ "mail.misc"))
@end lisp
You can combine this with traditional filtering. Here, we move all
@lisp
(setq nnmail-split-fancy
`(| ("Content-Type" "text/html" "mail.spam.filtered")
- (: spam-stat-split-fancy)
- ("Subject" "\\bspam-stat\\b" "mail.emacs")
- "mail.misc"))
+ (: spam-stat-split-fancy)
+ ("Subject" "\\bspam-stat\\b" "mail.emacs")
+ "mail.misc"))
@end lisp
@lisp
(setq mail-sources
'((directory :path "~/mail/incoming/"
- :suffix ".in")))
+ :suffix ".in")))
@end lisp
@xref{Mail Source Specifiers}.
@lisp
(setq gnus-parameters
'(("mail\\..*"
- (gnus-show-threads nil)
- (gnus-use-scoring nil))
- ("^nnimap:\\(foo.bar\\)$"
- (to-group . "\\1"))))
+ (gnus-show-threads nil)
+ (gnus-use-scoring nil))
+ ("^nnimap:\\(foo.bar\\)$"
+ (to-group . "\\1"))))
@end lisp
@item
The old format like the lines below is obsolete, but still accepted.
@lisp
(header "to" "larsi.*org"
- (Organization "Somewhere, Inc."))
+ (Organization "Somewhere, Inc."))
@end lisp
@item
(deffoo nndir-open-server (server &optional defs)
(setq nndir-directory
- (or (cadr (assq 'nndir-directory defs))
- server))
+ (or (cadr (assq 'nndir-directory defs))
+ server))
(unless (assq 'nndir-directory defs)
(push `(nndir-directory ,server) defs))
(push `(nndir-current-group
- ,(file-name-nondirectory
- (directory-file-name nndir-directory)))
- defs)
+ ,(file-name-nondirectory
+ (directory-file-name nndir-directory)))
+ defs)
(push `(nndir-top-directory
- ,(file-name-directory (directory-file-name nndir-directory)))
- defs)
+ ,(file-name-directory (directory-file-name nndir-directory)))
+ defs)
(nnoo-change-server 'nndir server defs))
(nnoo-map-functions nndir
date-rule = "(" quote date-header quote space *date-match ")"
quote = <ascii 34>
string-header = "subject" / "from" / "references" / "message-id" /
- "xref" / "body" / "head" / "all" / "followup"
+ "xref" / "body" / "head" / "all" / "followup"
number-header = "lines" / "chars"
date-header = "date"
string-match = "(" quote <string> quote [ "" / [ space score [ "" /
- space date [ "" / [ space string-match-t ] ] ] ] ] ")"
+ space date [ "" / [ space string-match-t ] ] ] ] ] ")"
score = "nil" / <integer>
date = "nil" / <natural number>
string-match-t = "nil" / "s" / "substring" / "S" / "Substring" /
- "r" / "regex" / "R" / "Regex" /
- "e" / "exact" / "E" / "Exact" /
- "f" / "fuzzy" / "F" / "Fuzzy"
+ "r" / "regex" / "R" / "Regex" /
+ "e" / "exact" / "E" / "Exact" /
+ "f" / "fuzzy" / "F" / "Fuzzy"
number-match = "(" <integer> [ "" / [ space score [ "" /
- space date [ "" / [ space number-match-t ] ] ] ] ] ")"
+ space date [ "" / [ space number-match-t ] ] ] ] ] ")"
number-match-t = "nil" / "=" / "<" / ">" / ">=" / "<="
date-match = "(" quote <string> quote [ "" / [ space score [ "" /
- space date [ "" / [ space date-match-t ] ] ] ] ")"
+ space date [ "" / [ space date-match-t ] ] ] ] ")"
date-match-t = "nil" / "at" / "before" / "after"
atom = "(" [ required-atom / optional-atom ] ")"
required-atom = mark / expunge / mark-and-expunge / files /
- exclude-files / read-only / touched
+ exclude-files / read-only / touched
optional-atom = adapt / local / eval
mark = "mark" space nil-or-number
nil-or-number = "nil" / <integer>
simple-range = "(" number " . " number ")"
normal-range = "(" start-contents ")"
contents = "" / simple-range *[ " " contents ] /
- number *[ " " contents ]
+ number *[ " " contents ]
@end example
Gnus currently uses ranges to keep track of read articles and article
("no.group" 5 ((1 . 54324)))
("nnml:my.mail" 3 ((1 . 5) 9 (20 . 55))
- ((tick (15 . 19)) (replied 3 6 (19 . 3)))
- (nnml "")
- ((auto-expire . t) (to-address . "ding@@gnus.org")))
+ ((tick (15 . 19)) (replied 3 6 (19 . 3)))
+ (nnml "")
+ ((auto-expire . t) (to-address . "ding@@gnus.org")))
@end example
The first element is the @dfn{group name}---as Gnus knows the group,
@example
info = "(" group space ralevel space read
- [ "" / [ space marks-list [ "" / [ space method [ "" /
- space parameters ] ] ] ] ] ")"
+ [ "" / [ space marks-list [ "" / [ space method [ "" /
+ space parameters ] ] ] ] ] ")"
group = quote <string> quote
ralevel = rank / level
level = <integer in the range of 1 to inf>
projects / gnus / blobdiff