(require 'nnheader)
(require 'nnmail)
-(eval-when-compile (require 'cl))
+(require 'nnoo)
+(require 'cl)
-(defvar nnml-directory "~/Mail/"
+(nnoo-declare nnml)
+
+(defvoo nnml-directory message-directory
"Mail spool directory.")
-(defvar nnml-active-file
+(defvoo nnml-active-file
(concat (file-name-as-directory nnml-directory) "active")
"Mail active file.")
-(defvar nnml-newsgroups-file
+(defvoo nnml-newsgroups-file
(concat (file-name-as-directory nnml-directory) "newsgroups")
"Mail newsgroups description file.")
-(defvar nnml-get-new-mail t
+(defvoo nnml-get-new-mail t
"If non-nil, nnml will check the incoming mail file and split the mail.")
-(defvar nnml-nov-is-evil nil
+(defvoo nnml-nov-is-evil nil
"If non-nil, Gnus will never generate and use nov databases for mail groups.
Using nov databases will speed up header fetching considerably.
This variable shouldn't be flipped much. If you have, for some reason,
through all nnml directories and generate nov databases for them
all. This may very well take some time.")
-(defvar nnml-prepare-save-mail-hook nil
+(defvoo nnml-prepare-save-mail-hook nil
"Hook run narrowed to an article before saving.")
-(defvar nnml-inhibit-expiry nil
+(defvoo nnml-inhibit-expiry nil
"If non-nil, inhibit expiry.")
(defconst nnml-version "nnml 1.0"
"nnml version.")
-(defvar nnml-nov-file-name ".overview")
+(defvoo nnml-nov-file-name ".overview")
-(defvar nnml-current-directory nil)
-(defvar nnml-current-group nil)
-(defvar nnml-status-string "")
-(defvar nnml-nov-buffer-alist nil)
-(defvar nnml-group-alist nil)
-(defvar nnml-active-timestamp nil)
-(defvar nnml-article-file-alist nil)
+(defvoo nnml-current-directory nil)
+(defvoo nnml-current-group nil)
+(defvoo nnml-status-string "")
+(defvoo nnml-nov-buffer-alist nil)
+(defvoo nnml-group-alist nil)
+(defvoo nnml-active-timestamp nil)
+(defvoo nnml-article-file-alist nil)
-(defvar nnml-generate-active-function 'nnml-generate-active-info)
-
-\f
-
-;; Server variables.
-
-(defvar nnml-current-server nil)
-(defvar nnml-server-alist nil)
-(defvar nnml-server-variables
- `((nnml-directory ,nnml-directory)
- (nnml-active-file ,nnml-active-file)
- (nnml-newsgroups-file ,nnml-newsgroups-file)
- (nnml-get-new-mail ,nnml-get-new-mail)
- (nnml-nov-is-evil ,nnml-nov-is-evil)
- (nnml-nov-file-name ,nnml-nov-file-name)
- (nnml-current-directory nil)
- (nnml-generate-active-function ,nnml-generate-active-function)
- (nnml-article-file-alist nil)
- (nnml-prepare-save-mail-hook nil)
- (nnml-current-group nil)
- (nnml-inhibit-expiry ,nnml-inhibit-expiry)
- (nnml-status-string "")
- (nnml-nov-buffer-alist nil)
- (nnml-group-alist nil)
- (nnml-active-timestamp nil)))
+(defvoo nnml-generate-active-function 'nnml-generate-active-info)
\f
;;; Interface functions.
-(defun nnml-retrieve-headers (sequence &optional newsgroup server fetch-old)
+(nnoo-define-basics nnml)
+
+(deffoo nnml-retrieve-headers (sequence &optional newsgroup server fetch-old)
(save-excursion
(set-buffer nntp-server-buffer)
(erase-buffer)
(nnheader-fold-continuation-lines)
'headers)))))
-(defun nnml-open-server (server &optional defs)
- (nnheader-change-server 'nnml server defs)
+(deffoo nnml-open-server (server &optional defs)
+ (nnoo-change-server 'nnml server defs)
(when (not (file-exists-p nnml-directory))
(condition-case ()
(make-directory nnml-directory t)
server nnml-directory)
t)))
-(defun nnml-close-server (&optional server)
- (setq nnml-current-server nil
- nnml-group-alist nil)
- t)
-
-(defun nnml-server-opened (&optional server)
- (and (equal server nnml-current-server)
- nntp-server-buffer
- (buffer-name nntp-server-buffer)))
-
-(defun nnml-status-message (&optional server)
- nnml-status-string)
-
-(defun nnml-request-article (id &optional newsgroup server buffer)
+(deffoo nnml-request-article (id &optional newsgroup server buffer)
(nnml-possibly-change-directory newsgroup server)
(let* ((nntp-server-buffer (or buffer nntp-server-buffer))
file path gpath group-num)
;; We return the article number.
(cons newsgroup (string-to-int (file-name-nondirectory path)))))))
-(defun nnml-request-group (group &optional server dont-check)
+(deffoo nnml-request-group (group &optional server dont-check)
(cond
((not (nnml-possibly-change-directory group server))
(nnheader-report 'nnml "Invalid group (no such directory)"))
+ ((not (file-directory-p nnml-current-directory))
+ (nnheader-report 'nnml "%s is not a directory" nnml-current-directory))
(dont-check
(nnheader-report 'nnml "Group %s selected" group)
t)
(max (1+ (- (cdr active) (car active))) 0)
(car active) (cdr active) group))))))
-(defun nnml-request-scan (&optional group server)
+(deffoo nnml-request-scan (&optional group server)
(setq nnml-article-file-alist nil)
(nnmail-get-new-mail 'nnml 'nnml-save-nov nnml-directory group))
-(defun nnml-close-group (group &optional server)
+(deffoo nnml-close-group (group &optional server)
(setq nnml-article-file-alist nil)
t)
-(defun nnml-request-close ()
- (setq nnml-current-server nil
- nnml-article-file-alist nil
- nnml-server-alist nil)
- t)
-
-(defun nnml-request-create-group (group &optional server)
+(deffoo nnml-request-create-group (group &optional server)
(nnmail-activate 'nnml)
(or (assoc group nnml-group-alist)
(let (active)
(nnmail-save-active nnml-group-alist nnml-active-file)))
t)
-(defun nnml-request-list (&optional server)
+(deffoo nnml-request-list (&optional server)
(save-excursion
(nnmail-find-file nnml-active-file)
(setq nnml-group-alist (nnmail-get-active))))
-(defun nnml-request-newgroups (date &optional server)
+(deffoo nnml-request-newgroups (date &optional server)
(nnml-request-list server))
-(defun nnml-request-list-newsgroups (&optional server)
+(deffoo nnml-request-list-newsgroups (&optional server)
(save-excursion
(nnmail-find-file nnml-newsgroups-file)))
-(defun nnml-request-expire-articles (articles newsgroup &optional server force)
+(deffoo nnml-request-expire-articles (articles newsgroup &optional server force)
(nnml-possibly-change-directory newsgroup server)
(let* ((active-articles
(nnheader-directory-articles nnml-current-directory))
(message "")
(nconc rest articles)))
-(defun nnml-request-move-article
+(deffoo nnml-request-move-article
(article group server accept-form &optional last)
(let ((buf (get-buffer-create " *nnml move*"))
result)
(kill-buffer (current-buffer))
result)
(progn
+ (nnml-possibly-change-directory group server)
(condition-case ()
(funcall nnmail-delete-file-function
(concat nnml-current-directory
(and last (nnml-save-nov))))
result))
-(defun nnml-request-accept-article (group &optional server last)
+(deffoo nnml-request-accept-article (group &optional server last)
(nnml-possibly-change-directory group server)
+ (nnmail-check-syntax)
(let (result)
(if (stringp group)
(and
(and last (nnml-save-nov)))))
result))
-(defun nnml-request-replace-article (article group buffer)
+(deffoo nnml-request-replace-article (article group buffer)
(nnml-possibly-change-directory group)
(save-excursion
(set-buffer buffer)
(nnml-possibly-create-directory group)
- (if (not (condition-case ()
- (progn
- (write-region (point-min) (point-max)
- (concat nnml-current-directory
- (int-to-string article))
- nil (if (nnheader-be-verbose 5) nil 'nomesg))
- t)
- (error nil)))
- ()
- (let ((chars (nnmail-insert-lines))
- (art (concat (int-to-string article) "\t"))
- nov-line)
- (setq nov-line (nnml-make-nov-line chars))
+ (let ((chars (nnmail-insert-lines))
+ (art (concat (int-to-string article) "\t"))
+ headers)
+ (when (condition-case ()
+ (progn
+ (write-region
+ (point-min) (point-max)
+ (concat nnml-current-directory (int-to-string article))
+ nil (if (nnheader-be-verbose 5) nil 'nomesg))
+ t)
+ (error nil))
+ (setq headers (nnml-parse-head chars article))
;; Replace the NOV line in the NOV file.
(save-excursion
(set-buffer (nnml-open-nov group))
article)
(zerop (forward-line 1)))))
(beginning-of-line)
- (insert (int-to-string article) nov-line)
+ (nnheader-insert-nov headers)
(nnml-save-nov)
t)))))
-(defun nnml-request-delete-group (group &optional force server)
+(deffoo nnml-request-delete-group (group &optional force server)
(nnml-possibly-change-directory group server)
(when force
;; Delete all articles in GROUP.
(nnmail-save-active nnml-group-alist nnml-active-file)
t)
-(defun nnml-request-rename-group (group new-name &optional server)
+(deffoo nnml-request-rename-group (group new-name &optional server)
(nnml-possibly-change-directory group server)
;; Rename directory.
(and (file-writable-p nnml-current-directory)
(defun nnml-save-mail ()
"Called narrowed to an article."
(let ((group-art (nreverse (nnmail-article-group 'nnml-active-number)))
- chars nov-line)
+ chars headers)
(setq chars (nnmail-insert-lines))
(nnmail-insert-xref group-art)
+ (run-hooks 'nnmail-prepare-save-mail-hook)
(run-hooks 'nnml-prepare-save-mail-hook)
(goto-char (point-min))
(while (looking-at "From ")
;; Generate a nov line for this article. We generate the nov
;; line after saving, because nov generation destroys the
;; header.
- (setq nov-line (nnml-make-nov-line chars))
+ (setq headers (nnml-parse-head chars))
;; Output the nov line to all nov databases that should have it.
(let ((ga group-art))
(while ga
- (nnml-add-nov (caar ga) (cdar ga) nov-line)
+ (nnml-add-nov (caar ga) (cdar ga) headers)
(setq ga (cdr ga))))
group-art))
(let ((active (cadr (assoc group nnml-group-alist))))
;; The group wasn't known to nnml, so we just create an active
;; entry for it.
- (or active
- (progn
- (setq active (cons 1 0))
- (setq nnml-group-alist (cons (list group active) nnml-group-alist))))
+ (unless active
+ ;; Perhaps the active file was corrupt? See whether
+ ;; there are any articles in this group.
+ (nnml-possibly-create-directory group)
+ (nnml-possibly-change-directory group)
+ (unless nnml-article-file-alist
+ (setq nnml-article-file-alist
+ (sort
+ (nnheader-article-to-file-alist nnml-current-directory)
+ (lambda (a1 a2) (< (car a1) (car a2))))))
+ (setq active
+ (if nnml-article-file-alist
+ (cons (caar nnml-article-file-alist)
+ (caar (last nnml-article-file-alist)))
+ (cons 1 0)))
+ (setq nnml-group-alist (cons (list group active) nnml-group-alist)))
(setcdr active (1+ (cdr active)))
(while (file-exists-p
(concat (nnmail-group-pathname group nnml-directory)
(setcdr active (1+ (cdr active))))
(cdr active)))
-(defun nnml-add-nov (group article line)
+(defun nnml-add-nov (group article headers)
"Add a nov line for the GROUP base."
(save-excursion
(set-buffer (nnml-open-nov group))
(goto-char (point-max))
- (insert (int-to-string article) line)))
+ (mail-header-set-number headers article)
+ (nnheader-insert-nov headers)))
(defsubst nnml-header-value ()
(buffer-substring (match-end 0) (progn (end-of-line) (point))))
-(defun nnml-make-nov-line (chars)
- "Create a nov from the current headers."
- (let ((case-fold-search t)
- subject from date id references lines xref in-reply-to char)
- (save-excursion
- (save-restriction
- (goto-char (point-min))
- (narrow-to-region
- (point)
- (1- (or (search-forward "\n\n" nil t) (point-max))))
- ;; Fold continuation lines.
- (goto-char (point-min))
- (while (re-search-forward "\\(\r?\n[ \t]+\\)+" nil t)
- (replace-match " " t t))
- (subst-char-in-region (point-min) (point-max) ?\t ? )
- ;; [number subject from date id references chars lines xref]
- (save-excursion
- (goto-char (point-min))
- (while (re-search-forward "^\\(from\\|subject\\|message-id\\|date\\|lines\\|xref\\|references\\|in-reply-to\\): "
- nil t)
- (beginning-of-line)
- (setq char (downcase (following-char)))
- (cond
- ((eq char ?s)
- (setq subject (nnml-header-value)))
- ((eq char ?f)
- (setq from (nnml-header-value)))
- ((eq char ?x)
- (setq xref (buffer-substring (match-beginning 0)
- (progn (end-of-line) (point)))))
- ((eq char ?l)
- (setq lines (nnml-header-value)))
- ((eq char ?d)
- (setq date (nnml-header-value)))
- ((eq char ?m)
- (setq id (setq id (nnml-header-value))))
- ((eq char ?r)
- (setq references (nnml-header-value)))
- ((eq char ?i)
- (setq in-reply-to (nnml-header-value))))
- (forward-line 1))
-
- (and (not references)
- in-reply-to
- (string-match "<[^>]+>" in-reply-to)
- (setq references
- (substring in-reply-to (match-beginning 0)
- (match-end 0)))))
- ;; [number subject from date id references chars lines xref]
- (format "\t%s\t%s\t%s\t%s\t%s\t%d\t%s\t%s\t\n"
- (or subject "(none)") (or from "(nobody)") (or date "")
- (or id (nnmail-message-id))
- (or references "") (or chars 0) (or lines "0")
- (or xref ""))))))
+(defun nnml-parse-head (chars &optional number)
+ "Parse the head of the current buffer."
+ (save-excursion
+ (save-restriction
+ (goto-char (point-min))
+ (narrow-to-region
+ (point)
+ (1- (or (search-forward "\n\n" nil t) (point-max))))
+ ;; Fold continuation lines.
+ (goto-char (point-min))
+ (while (re-search-forward "\\(\r?\n[ \t]+\\)+" nil t)
+ (replace-match " " t t))
+ ;; Remove any tabs; they are too confusing.
+ (subst-char-in-region (point-min) (point-max) ?\t ? )
+ (let ((headers (nnheader-parse-head t)))
+ (mail-header-set-chars headers chars)
+ (mail-header-set-number headers number)
+ headers))))
(defun nnml-open-nov (group)
(or (cdr (assoc group nnml-nov-buffer-alist))
;; Read the active file to make sure we don't re-use articles
;; numbers in empty groups.
(nnmail-activate 'nnml)
- (nnml-open-server (or nnml-current-server ""))
+ (nnml-open-server (or (nnoo-current-server 'nnml) ""))
(setq nnml-directory (expand-file-name nnml-directory))
;; Recurse down the directories.
(nnml-generate-nov-databases-1 nnml-directory)
dir)
(while dirs
(setq dir (pop dirs))
- (when (and (not (string-match "/\\.\\.?$" dir))
+ (when (and (not (member (file-name-nondirectory dir) '("." "..")))
(file-directory-p dir))
(nnml-generate-nov-databases-1 dir))))
;; Do this directory.
;; Generate the nov file.
(nnml-generate-nov-file dir files))))
+(defvar files)
(defun nnml-generate-active-info (dir)
;; Update the active info for this group.
(let ((group (nnheader-file-to-group
(let* ((dir (file-name-as-directory dir))
(nov (concat dir nnml-nov-file-name))
(nov-buffer (get-buffer-create " *nov*"))
- nov-line chars file)
+ nov-line chars file headers)
(save-excursion
;; Init the nov buffer.
(set-buffer nov-buffer)
(when (and (not (= 0 chars)) ; none of them empty files...
(not (= (point-min) (point-max))))
(goto-char (point-min))
- (setq nov-line (nnml-make-nov-line chars))
+ (setq headers (nnml-parse-head chars (car files)))
(save-excursion
(set-buffer nov-buffer)
(goto-char (point-max))
- (insert (int-to-string (car files)) nov-line)))
+ (nnheader-insert-nov headers)))
(widen))
(setq files (cdr files)))
(save-excursion
projects / gnus / blobdiff