;;; gnus-agent.el --- unplugged support for Gnus
-;; Copyright (C) 1997,98 Free Software Foundation, Inc.
+;; Copyright (C) 1997,98,99 Free Software Foundation, Inc.
;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
;; This file is part of GNU Emacs.
(require 'gnus-cache)
(require 'nnvirtual)
(require 'gnus-sum)
-(eval-when-compile (require 'cl))
+(eval-when-compile
+ (require 'cl)
+ (require 'gnus-score))
(defcustom gnus-agent-directory (nnheader-concat gnus-directory "agent/")
"Where the Gnus agent will store its files."
;;; Internal variables
-(defvar gnus-agent-meta-information-header "X-Gnus-Agent-Meta-Information")
-
(defvar gnus-agent-history-buffers nil)
(defvar gnus-agent-buffer-alist nil)
(defvar gnus-agent-article-alist nil)
(defvar gnus-agent-spam-hashtb nil)
(defvar gnus-agent-file-name nil)
(defvar gnus-agent-send-mail-function nil)
-(defvar gnus-agent-article-file-coding-system 'no-conversion)
+(defvar gnus-agent-file-coding-system 'raw-text)
+
+(defconst gnus-agent-scoreable-headers
+ '("subject" "from" "date" "message-id" "references" "chars" "lines" "xref")
+ "Headers that are considered when scoring articles for download via the Agent.")
;; Dynamic variables
(defvar gnus-headers)
(setq gnus-agent t)
(gnus-agent-read-servers)
(gnus-category-read)
- (setq gnus-agent-overview-buffer
- (get-buffer-create " *Gnus agent overview*"))
+ (gnus-agent-create-buffer)
(add-hook 'gnus-group-mode-hook 'gnus-agent-mode)
(add-hook 'gnus-summary-mode-hook 'gnus-agent-mode)
(add-hook 'gnus-server-mode-hook 'gnus-agent-mode))
+(defun gnus-agent-create-buffer ()
+ (if (gnus-buffer-live-p gnus-agent-overview-buffer)
+ t
+ (setq gnus-agent-overview-buffer
+ (gnus-get-buffer-create " *Gnus agent overview*"))
+ (with-current-buffer gnus-agent-overview-buffer
+ (mm-enable-multibyte))
+ nil))
+
(gnus-add-shutdown 'gnus-close-agent 'gnus)
(defun gnus-close-agent ()
(defun gnus-agent-read-file (file)
"Load FILE and do a `read' there."
- (nnheader-temp-write nil
+ (with-temp-buffer
(ignore-errors
- (insert-file-contents file)
+ (nnheader-insert-file-contents file)
(goto-char (point-min))
(read (current-buffer)))))
(defun gnus-agent-start-fetch ()
"Initialize data structures for efficient fetching."
(gnus-agent-open-history)
- (setq gnus-agent-current-history (gnus-agent-history-buffer)))
+ (setq gnus-agent-current-history (gnus-agent-history-buffer))
+ (gnus-agent-create-buffer))
(defun gnus-agent-stop-fetch ()
"Save all data structures and clean up."
(push (cons mode (symbol-value (intern (format "gnus-agent-%s-mode-map"
buffer))))
minor-mode-map-alist))
- (gnus-agent-toggle-plugged gnus-plugged)
+ (when (eq major-mode 'gnus-group-mode)
+ (gnus-agent-toggle-plugged gnus-plugged))
(gnus-run-hooks 'gnus-agent-mode-hook
(intern (format "gnus-agent-%s-mode-hook" buffer)))))
"Jj" gnus-agent-toggle-plugged
"Js" gnus-agent-fetch-session
"JS" gnus-group-send-drafts
- "Ja" gnus-agent-add-group)
+ "Ja" gnus-agent-add-group
+ "Jr" gnus-agent-remove-group)
(defun gnus-agent-group-make-menu-bar ()
(unless (boundp 'gnus-agent-group-menu)
(interactive)
(gnus-open-agent)
(add-hook 'gnus-setup-news-hook 'gnus-agent-queue-setup)
- (unless gnus-agent-send-mail-function
+ (unless gnus-agent-send-mail-function
(setq gnus-agent-send-mail-function message-send-mail-function
message-send-mail-function 'gnus-agent-send-mail))
(unless gnus-agent-covered-methods
(concat "^" (regexp-quote mail-header-separator) "\n"))
(replace-match "\n")
(gnus-agent-insert-meta-information 'mail)
- (gnus-request-accept-article "nndraft:queue")))
+ (gnus-request-accept-article "nndraft:queue" nil t t)))
(defun gnus-agent-insert-meta-information (type &optional method)
"Insert meta-information into the message that says how it's to be posted.
(defun gnus-agent-fetch-groups (n)
"Put all new articles in the current groups into the Agent."
(interactive "P")
+ (unless gnus-plugged
+ (error "Groups can't be fetched when Gnus is unplugged"))
(gnus-group-iterate n 'gnus-agent-fetch-group))
(defun gnus-agent-fetch-group (group)
"Put all new articles in GROUP into the Agent."
(interactive (list (gnus-group-group-name)))
+ (unless gnus-plugged
+ (error "Groups can't be fetched when Gnus is unplugged"))
(unless group
(error "No group on the current line"))
(let ((gnus-command-method (gnus-find-method-for-group group)))
(setf (cadddr cat) (nconc (cadddr cat) groups))
(gnus-category-write)))
+(defun gnus-agent-remove-group (arg)
+ "Remove the current group from its agent category, if any."
+ (interactive "P")
+ (let (c)
+ (gnus-group-iterate arg
+ (lambda (group)
+ (when (cadddr (setq c (gnus-group-category group)))
+ (setf (cadddr c) (delete group (cadddr c))))))
+ (gnus-category-write)))
+
;;;
;;; Server mode commands
;;;
(defun gnus-agent-write-servers ()
"Write the alist of covered servers."
- (nnheader-temp-write (nnheader-concat gnus-agent-directory "lib/servers")
+ (gnus-make-directory (nnheader-concat gnus-agent-directory "lib"))
+ (with-temp-file (nnheader-concat gnus-agent-directory "lib/servers")
(prin1 gnus-agent-covered-methods (current-buffer))))
;;;
(when (and (not gnus-plugged)
(gnus-agent-method-p gnus-command-method))
(gnus-agent-load-alist gnus-newsgroup-name)
- (let ((articles gnus-newsgroup-unreads)
+ ;; First mark all undownloaded articles as undownloaded.
+ (let ((articles (append gnus-newsgroup-unreads
+ gnus-newsgroup-marked
+ gnus-newsgroup-dormant))
article)
(while (setq article (pop articles))
(unless (or (cdr (assq article gnus-agent-article-alist))
- (memq article gnus-newsgroup-downloadable))
- (push article gnus-newsgroup-undownloaded)))))))
+ (memq article gnus-newsgroup-downloadable)
+ (memq article gnus-newsgroup-cached))
+ (push article gnus-newsgroup-undownloaded))))
+ ;; Then mark downloaded downloadable as not-downloadable,
+ ;; if you get my drift.
+ (let ((articles gnus-newsgroup-downloadable)
+ article)
+ (while (setq article (pop articles))
+ (when (cdr (assq article gnus-agent-article-alist))
+ (setq gnus-newsgroup-downloadable
+ (delq article gnus-newsgroup-downloadable))))))))
(defun gnus-agent-catchup ()
"Mark all undownloaded articles as read."
;;;
(defun gnus-agent-save-active (method)
+ (gnus-agent-save-active-1 method 'gnus-active-to-gnus-format))
+
+(defun gnus-agent-save-active-1 (method function)
(when (gnus-agent-method-p method)
(let* ((gnus-command-method method)
+ (new (gnus-make-hashtable (count-lines (point-min) (point-max))))
(file (gnus-agent-lib-file "active")))
- (gnus-make-directory (file-name-directory file))
- (let ((coding-system-for-write gnus-agent-article-file-coding-system))
- (write-region (point-min) (point-max) file nil 'silent))
- (when (file-exists-p (gnus-agent-lib-file "groups"))
- (delete-file (gnus-agent-lib-file "groups"))))))
+ (funcall function nil new)
+ (gnus-agent-write-active file new)
+ (erase-buffer)
+ (insert-file-contents-literally file))))
+
+(defun gnus-agent-write-active (file new)
+ (let ((orig (gnus-make-hashtable (count-lines (point-min) (point-max))))
+ (file (gnus-agent-lib-file "active"))
+ elem osym)
+ (when (file-exists-p file)
+ (with-temp-buffer
+ (insert-file-contents file)
+ (gnus-active-to-gnus-format nil orig))
+ (mapatoms
+ (lambda (sym)
+ (when (and sym (boundp sym))
+ (if (and (boundp (setq osym (intern (symbol-name sym) orig)))
+ (setq elem (symbol-value osym)))
+ (setcdr elem (cdr (symbol-value sym)))
+ (set (intern (symbol-name sym) orig) (symbol-value sym)))))
+ new))
+ (gnus-make-directory (file-name-directory file))
+ (let ((coding-system-for-write gnus-agent-file-coding-system))
+ (gnus-write-active-file file orig))))
(defun gnus-agent-save-groups (method)
- (let* ((gnus-command-method method)
- (file (gnus-agent-lib-file "groups")))
- (gnus-make-directory (file-name-directory file))
- (write-region (point-min) (point-max) file nil 'silent))
- (when (file-exists-p (gnus-agent-lib-file "active"))
- (delete-file (gnus-agent-lib-file "active"))))
+ (gnus-agent-save-active-1 method 'gnus-groups-to-gnus-format))
(defun gnus-agent-save-group-info (method group active)
(when (gnus-agent-method-p method)
(let* ((gnus-command-method method)
(file (gnus-agent-lib-file "active")))
(gnus-make-directory (file-name-directory file))
- (nnheader-temp-write file
- (insert-file-contents file)
+ (with-temp-file file
+ (when (file-exists-p file)
+ (nnheader-insert-file-contents file))
(goto-char (point-min))
- (when (re-search-forward (concat "^" (regexp-quote group) " ") nil t)
+ (when (re-search-forward
+ (concat "^" (regexp-quote group) " ") nil t)
(gnus-delete-line))
(insert group " " (number-to-string (cdr active)) " "
- (number-to-string (car active)) "\n")))))
+ (number-to-string (car active)) " y\n")))))
(defun gnus-agent-group-path (group)
"Translate GROUP into a path."
(defun gnus-agent-open-history ()
(save-excursion
(push (cons (gnus-agent-method)
- (set-buffer (get-buffer-create
+ (set-buffer (gnus-get-buffer-create
(format " *Gnus agent %s history*"
(gnus-agent-method)))))
gnus-agent-history-buffers)
(save-excursion
(set-buffer gnus-agent-current-history)
(gnus-make-directory (file-name-directory gnus-agent-file-name))
- (write-region (1+ (point-min)) (point-max)
- gnus-agent-file-name nil 'silent)))
+ (let ((coding-system-for-write gnus-agent-file-coding-system))
+ (write-region (1+ (point-min)) (point-max)
+ gnus-agent-file-name nil 'silent))))
(defun gnus-agent-close-history ()
(when (gnus-buffer-live-p gnus-agent-current-history)
;; Prune off articles that we have already fetched.
(while (and articles
(cdr (assq (car articles) gnus-agent-article-alist)))
- (pop articles))
+ (pop articles))
(let ((arts articles))
(while (cdr arts)
(if (cdr (assq (cadr arts) gnus-agent-article-alist))
(let ((dir (concat
(gnus-agent-directory)
(gnus-agent-group-path group) "/"))
- (date (gnus-time-to-day (current-time)))
+ (date (time-to-days (current-time)))
(case-fold-search t)
- pos alists crosses id elem)
+ pos crosses id elem)
(gnus-make-directory dir)
(gnus-message 7 "Fetching articles for %s..." group)
;; Fetch the articles from the backend.
(if (gnus-check-backend-function 'retrieve-articles group)
(setq pos (gnus-retrieve-articles articles group))
- (nnheader-temp-write nil
- (let ((buf (current-buffer))
- article)
+ (with-temp-buffer
+ (let (article)
(while (setq article (pop articles))
(when (gnus-request-article article group)
(goto-char (point-max))
(setq id "No-Message-ID-in-article")
(setq id (buffer-substring (match-beginning 1) (match-end 1))))
(let ((coding-system-for-write
- gnus-agent-article-file-coding-system))
+ gnus-agent-file-coding-system))
(write-region (point-min) (point-max)
(concat dir (number-to-string (caar pos)))
nil 'silent))
gnus-agent-group-alist))
(setcdr alist (cons (cons (cdar crosses) t) (cdr alist)))
(save-excursion
- (set-buffer (get-buffer-create (format " *Gnus agent overview %s*"
+ (set-buffer (gnus-get-buffer-create (format " *Gnus agent overview %s*"
group)))
(when (= (point-max) (point-min))
(push (cons group (current-buffer)) gnus-agent-buffer-alist)
(ignore-errors
- (insert-file-contents
+ (nnheader-insert-file-contents
(gnus-agent-article-name ".overview" group))))
(nnheader-find-nov-line (string-to-number (cdar crosses)))
(insert (string-to-number (cdar crosses)))
(save-excursion
(while gnus-agent-buffer-alist
(set-buffer (cdar gnus-agent-buffer-alist))
- (write-region (point-min) (point-max)
- (gnus-agent-article-name ".overview"
- (caar gnus-agent-buffer-alist))
- nil 'silent)
+ (let ((coding-system-for-write
+ gnus-agent-file-coding-system))
+ (write-region (point-min) (point-max)
+ (gnus-agent-article-name ".overview"
+ (caar gnus-agent-buffer-alist))
+ nil 'silent))
(pop gnus-agent-buffer-alist))
(while gnus-agent-group-alist
- (nnheader-temp-write (caar gnus-agent-group-alist)
+ (with-temp-file (caar gnus-agent-group-alist)
(princ (cdar gnus-agent-group-alist))
(insert "\n"))
(pop gnus-agent-group-alist))))
-(defun gnus-agent-fetch-headers (group articles &optional force)
- (gnus-agent-load-alist group)
- ;; Find out what headers we need to retrieve.
- (when articles
- (while (and articles
- (assq (car articles) gnus-agent-article-alist))
- (pop articles))
- (let ((arts articles))
- (while (cdr arts)
- (if (assq (cadr arts) gnus-agent-article-alist)
- (setcdr arts (cddr arts))
- (setq arts (cdr arts)))))
+(defun gnus-agent-fetch-headers (group &optional force)
+ (let ((articles (gnus-list-of-unread-articles group))
+ (gnus-decode-encoded-word-function 'identity)
+ (file (gnus-agent-article-name ".overview" group)))
+ ;; add article with marks to list of article headers we want to fetch
+ (dolist (arts (gnus-info-marks (gnus-get-info group)))
+ (setq articles (union (gnus-uncompress-sequence (cdr arts))
+ articles)))
+ (setq articles (sort articles '<))
+ ;; remove known articles
+ (when (gnus-agent-load-alist group)
+ (setq articles (gnus-sorted-intersection
+ articles
+ (gnus-uncompress-range
+ (cons (1+ (caar (last gnus-agent-article-alist)))
+ (cdr (gnus-active group)))))))
;; Fetch them.
+ (gnus-make-directory (nnheader-translate-file-chars
+ (file-name-directory file)))
(when articles
(gnus-message 7 "Fetching headers for %s..." group)
(save-excursion
- (set-buffer nntp-server-buffer)
- (unless (eq 'nov (gnus-retrieve-headers articles group))
- (nnvirtual-convert-headers))
- ;; Save these headers for later processing.
- (copy-to-buffer gnus-agent-overview-buffer (point-min) (point-max))
- (let (file)
- (when (file-exists-p
- (setq file (gnus-agent-article-name ".overview" group)))
- (gnus-agent-braid-nov group articles file))
- (gnus-make-directory (nnheader-translate-file-chars
- (file-name-directory file)))
- (write-region (point-min) (point-max) file nil 'silent)
- (gnus-agent-save-alist group articles nil))
- t))))
+ (set-buffer nntp-server-buffer)
+ (unless (eq 'nov (gnus-retrieve-headers articles group))
+ (nnvirtual-convert-headers))
+ ;; Save these headers for later processing.
+ (copy-to-buffer gnus-agent-overview-buffer (point-min) (point-max))
+ (when (file-exists-p file)
+ (gnus-agent-braid-nov group articles file))
+ (let ((coding-system-for-write
+ gnus-agent-file-coding-system))
+ (write-region (point-min) (point-max) file nil 'silent))
+ (gnus-agent-save-alist group articles nil)
+ (gnus-agent-enter-history
+ "last-header-fetched-for-session"
+ (list (cons group (nth (- (length articles) 1) articles)))
+ (time-to-days (current-time)))
+ articles))))
(defsubst gnus-agent-copy-nov-line (article)
(let (b e)
(setq b (point))
(if (eq article (read (current-buffer)))
(setq e (progn (forward-line 1) (point)))
- (setq e b))
+ (progn
+ (beginning-of-line)
+ (setq e b)))
(set-buffer nntp-server-buffer)
(insert-buffer-substring gnus-agent-overview-buffer b e)))
(defun gnus-agent-braid-nov (group articles file)
- (let (beg end)
- (set-buffer gnus-agent-overview-buffer)
- (goto-char (point-min))
- (set-buffer nntp-server-buffer)
- (erase-buffer)
- (insert-file-contents file)
- (goto-char (point-min))
- (if (or (= (point-min) (point-max))
- (progn
- (forward-line -1)
- (< (read (current-buffer)) (car articles))))
- ;; We have only headers that are after the older headers,
- ;; so we just append them.
- (progn
- (goto-char (point-max))
- (insert-buffer-substring gnus-agent-overview-buffer))
- ;; We do it the hard way.
- (nnheader-find-nov-line (car articles))
- (gnus-agent-copy-nov-line (car articles))
- (pop articles)
- (while (and articles
- (not (eobp)))
- (while (and (not (eobp))
- (< (read (current-buffer)) (car articles)))
- (forward-line 1))
- (beginning-of-line)
- (unless (eobp)
- (gnus-agent-copy-nov-line (car articles))
- (setq articles (cdr articles))))
- (when articles
- (let (b e)
- (set-buffer gnus-agent-overview-buffer)
- (setq b (point)
- e (point-max))
- (set-buffer nntp-server-buffer)
- (insert-buffer-substring gnus-agent-overview-buffer b e))))))
+ (set-buffer gnus-agent-overview-buffer)
+ (goto-char (point-min))
+ (set-buffer nntp-server-buffer)
+ (erase-buffer)
+ (nnheader-insert-file-contents file)
+ (goto-char (point-max))
+ (if (or (= (point-min) (point-max))
+ (progn
+ (forward-line -1)
+ (< (read (current-buffer)) (car articles))))
+ ;; We have only headers that are after the older headers,
+ ;; so we just append them.
+ (progn
+ (goto-char (point-max))
+ (insert-buffer-substring gnus-agent-overview-buffer))
+ ;; We do it the hard way.
+ (nnheader-find-nov-line (car articles))
+ (gnus-agent-copy-nov-line (car articles))
+ (pop articles)
+ (while (and articles
+ (not (eobp)))
+ (while (and (not (eobp))
+ (< (read (current-buffer)) (car articles)))
+ (forward-line 1))
+ (beginning-of-line)
+ (unless (eobp)
+ (gnus-agent-copy-nov-line (car articles))
+ (setq articles (cdr articles))))
+ (when articles
+ (let (b e)
+ (set-buffer gnus-agent-overview-buffer)
+ (setq b (point)
+ e (point-max))
+ (set-buffer nntp-server-buffer)
+ (insert-buffer-substring gnus-agent-overview-buffer b e)))))
(defun gnus-agent-load-alist (group &optional dir)
"Load the article-state alist for GROUP."
(gnus-agent-article-name ".agentview" group)))))
(defun gnus-agent-save-alist (group &optional articles state dir)
- "Load the article-state alist for GROUP."
- (nnheader-temp-write (if dir
- (concat dir ".agentview")
- (gnus-agent-article-name ".agentview" group))
+ "Save the article-state alist for GROUP."
+ (with-temp-file (if dir
+ (concat dir ".agentview")
+ (gnus-agent-article-name ".agentview" group))
(princ (setq gnus-agent-article-alist
(nconc gnus-agent-article-alist
(mapcar (lambda (article) (cons article state))
(defun gnus-agent-fetch-group-1 (group method)
"Fetch GROUP."
(let ((gnus-command-method method)
+ (gnus-newsgroup-name group)
gnus-newsgroup-dependencies gnus-newsgroup-headers
gnus-newsgroup-scored gnus-headers gnus-score
- gnus-use-cache articles score arts
+ gnus-use-cache articles arts
category predicate info marks score-param)
;; Fetch headers.
(when (and (or (gnus-active group) (gnus-activate-group group))
- (setq articles (gnus-list-of-unread-articles group))
- (gnus-agent-fetch-headers group articles))
- ;; Parse them and see which articles we want to fetch.
- (setq gnus-newsgroup-dependencies
- (make-vector (length articles) 0))
- (setq gnus-newsgroup-headers
- (gnus-get-newsgroup-headers-xover articles nil nil group))
+ (setq articles (gnus-agent-fetch-headers group))
+ (progn
+ ;; Parse them and see which articles we want to fetch.
+ (setq gnus-newsgroup-dependencies
+ (make-vector (length articles) 0))
+ ;; No need to call `gnus-get-newsgroup-headers-xover' with
+ ;; the entire .overview for group as we still have the just
+ ;; downloaded headers in `gnus-agent-overview-buffer'.
+ (let ((nntp-server-buffer gnus-agent-overview-buffer))
+ (setq gnus-newsgroup-headers
+ (gnus-get-newsgroup-headers-xover articles nil nil
+ group)))
+ ;; `gnus-agent-overview-buffer' may be killed for
+ ;; timeout reason. If so, recreate it.
+ (gnus-agent-create-buffer)))
(setq category (gnus-group-category group))
(setq predicate
- (gnus-get-predicate
- (or (gnus-group-get-parameter group 'agent-predicate)
+ (gnus-get-predicate
+ (or (gnus-group-find-parameter group 'agent-predicate t)
(cadr category))))
- (setq score-param
- (or (gnus-group-get-parameter group 'agent-score)
- (caddr category)))
- (when score-param
- (gnus-score-headers (list (list score-param))))
- (setq arts nil)
- (while (setq gnus-headers (pop gnus-newsgroup-headers))
- (setq gnus-score
- (or (cdr (assq (mail-header-number gnus-headers)
- gnus-newsgroup-scored))
- gnus-summary-default-score))
- (when (funcall predicate)
- (push (mail-header-number gnus-headers)
- arts)))
+ ;; Do we want to download everything, or nothing?
+ (if (or (eq (caaddr predicate) 'gnus-agent-true)
+ (eq (caaddr predicate) 'gnus-agent-false))
+ ;; Yes.
+ (setq arts (symbol-value
+ (cadr (assoc (caaddr predicate)
+ '((gnus-agent-true articles)
+ (gnus-agent-false nil))))))
+ ;; No, we need to decide what we want.
+ (setq score-param
+ (let ((score-method
+ (or
+ (gnus-group-find-parameter group 'agent-score t)
+ (caddr category))))
+ (when score-method
+ (require 'gnus-score)
+ (if (eq score-method 'file)
+ (let ((entries
+ (gnus-score-load-files
+ (gnus-all-score-files group)))
+ list score-file)
+ (while (setq list (car entries))
+ (push (car list) score-file)
+ (setq list (cdr list))
+ (while list
+ (when (member (caar list)
+ gnus-agent-scoreable-headers)
+ (push (car list) score-file))
+ (setq list (cdr list)))
+ (setq score-param
+ (append score-param (list (nreverse score-file)))
+ score-file nil entries (cdr entries)))
+ (list score-param))
+ (if (stringp (car score-method))
+ score-method
+ (list (list score-method)))))))
+ (when score-param
+ (gnus-score-headers score-param))
+ (setq arts nil)
+ (while (setq gnus-headers (pop gnus-newsgroup-headers))
+ (setq gnus-score
+ (or (cdr (assq (mail-header-number gnus-headers)
+ gnus-newsgroup-scored))
+ gnus-summary-default-score))
+ (when (funcall predicate)
+ (push (mail-header-number gnus-headers)
+ arts))))
;; Fetch the articles.
(when arts
(gnus-agent-fetch-articles group arts)))
(gnus-agent-fetch-articles
group (gnus-uncompress-range (cdr arts)))
(setq marks (delq arts (gnus-info-marks info)))
- (gnus-info-set-marks info marks))))
+ (gnus-info-set-marks info marks)
+ (gnus-dribble-enter
+ (concat "(gnus-group-set-info '"
+ (gnus-prin1-to-string info)
+ ")")))))
;;;
;;; Agent Category Mode
(defvar gnus-category-buffer "*Agent Category*")
(defvar gnus-category-line-format-alist
- `((?c name ?s)
- (?g groups ?d)))
+ `((?c gnus-tmp-name ?s)
+ (?g gnus-tmp-groups ?d)))
(defvar gnus-category-mode-line-format-alist
`((?u user-defined ?s)))
(gnus-set-default-directory)
(setq mode-line-process nil)
(use-local-map gnus-category-mode-map)
- (buffer-disable-undo (current-buffer))
+ (buffer-disable-undo)
(setq truncate-lines t)
(setq buffer-read-only t)
(gnus-run-hooks 'gnus-category-mode-hook))
(defalias 'gnus-category-position-point 'gnus-goto-colon)
(defun gnus-category-insert-line (category)
- (let* ((name (car category))
- (groups (length (cadddr category))))
+ (let* ((gnus-tmp-name (car category))
+ (gnus-tmp-groups (length (cadddr category))))
(beginning-of-line)
(gnus-add-text-properties
(point)
(prog1 (1+ (point))
;; Insert the text.
(eval gnus-category-line-format-spec))
- (list 'gnus-category name))))
+ (list 'gnus-category gnus-tmp-name))))
(defun gnus-enter-category-buffer ()
"Go to the Category buffer."
(defun gnus-category-setup-buffer ()
(unless (get-buffer gnus-category-buffer)
(save-excursion
- (set-buffer (get-buffer-create gnus-category-buffer))
- (gnus-add-current-to-buffer-list)
+ (set-buffer (gnus-get-buffer-create gnus-category-buffer))
(gnus-category-mode))))
(defun gnus-category-prepare ()
(or (gnus-agent-read-file
(nnheader-concat gnus-agent-directory "lib/categories"))
(list (list 'default 'short nil nil)))))
-
+
(defun gnus-category-write ()
"Write the category alist."
(setq gnus-category-predicate-cache nil
gnus-category-group-cache nil)
- (nnheader-temp-write (nnheader-concat gnus-agent-directory "lib/categories")
+ (gnus-make-directory (nnheader-concat gnus-agent-directory "lib"))
+ (with-temp-file (nnheader-concat gnus-agent-directory "lib/categories")
(prin1 gnus-category-alist (current-buffer))))
(defun gnus-category-edit-predicate (category)
(setf (cadr (assq ',category gnus-category-alist)) predicate)
(gnus-category-write)
(gnus-category-list)))))
-
+
(defun gnus-category-edit-score (category)
"Edit the score expression for CATEGORY."
(interactive (list (gnus-category-name)))
(interactive "SCategory name: ")
(when (assq category gnus-category-alist)
(error "Category %s already exists" category))
- (push (list category 'true nil nil)
+ (push (list category 'false nil nil)
gnus-category-alist)
(gnus-category-write)
(gnus-category-list))
(defun gnus-agent-false ()
"Return nil."
nil)
-
+
(defun gnus-category-make-function-1 (cat)
"Make a function from category CAT."
(cond
"Expire all old articles."
(interactive)
(let ((methods gnus-agent-covered-methods)
- (day (- (gnus-time-to-day (current-time)) gnus-agent-expire-days))
- (expiry-hashtb (gnus-make-hashtable 1023))
+ (day (- (time-to-days (current-time)) gnus-agent-expire-days))
gnus-command-method sym group articles
history overview file histories elem art nov-file low info
- unreads marked article)
+ unreads marked article orig lowest highest)
(save-excursion
- (setq overview (get-buffer-create " *expire overview*"))
+ (setq overview (gnus-get-buffer-create " *expire overview*"))
(while (setq gnus-command-method (pop methods))
- (gnus-agent-open-history)
- (set-buffer
- (setq gnus-agent-current-history
- (setq history (gnus-agent-history-buffer))))
- (goto-char (point-min))
- (when (> (buffer-size) 1)
- (goto-char (point-min))
- (while (not (eobp))
- (skip-chars-forward "^\t")
- (if (> (read (current-buffer)) day)
- ;; New article; we don't expire it.
- (forward-line 1)
- ;; Old article. Schedule it for possible nuking.
- (while (not (eolp))
- (setq sym (let ((obarray expiry-hashtb))
- (read (current-buffer))))
- (if (boundp sym)
- (set sym (cons (cons (read (current-buffer)) (point))
- (symbol-value sym)))
- (set sym (list (cons (read (current-buffer)) (point)))))
- (skip-chars-forward " "))
- (forward-line 1)))
- ;; We now have all articles that can possibly be expired.
- (mapatoms
- (lambda (sym)
- (setq group (symbol-name sym)
- articles (sort (symbol-value sym) 'car-less-than-car)
- low (car (gnus-active group))
- info (gnus-get-info group)
- unreads (ignore-errors (gnus-list-of-unread-articles group))
- marked (nconc (gnus-uncompress-range
- (cdr (assq 'ticked (gnus-info-marks info))))
- (gnus-uncompress-range
- (cdr (assq 'dormant
- (gnus-info-marks info)))))
- nov-file (gnus-agent-article-name ".overview" group))
- (gnus-agent-load-alist group)
- (gnus-message 5 "Expiring articles in %s" group)
- (set-buffer overview)
- (erase-buffer)
- (when (file-exists-p nov-file)
- (insert-file-contents nov-file))
- (goto-char (point-min))
- (setq article 0)
- (while (setq elem (pop articles))
- (setq article (car elem))
- (when (or (null low)
- (< article low)
- gnus-agent-expire-all
- (and (not (memq article unreads))
- (not (memq article marked))))
- ;; Find and nuke the NOV line.
- (while (and (not (eobp))
- (or (not (numberp
- (setq art (read (current-buffer)))))
- (< art article)))
- (if (file-exists-p
- (gnus-agent-article-name
- (number-to-string article) group))
- (forward-line 1)
- ;; Remove old NOV lines that have no articles.
- (gnus-delete-line)))
- (if (or (eobp)
- (/= art article))
- (beginning-of-line)
- (gnus-delete-line))
- ;; Nuke the article.
- (when (file-exists-p (setq file (gnus-agent-article-name
- (number-to-string article)
- group)))
- (delete-file file))
- ;; Schedule the history line for nuking.
- (push (cdr elem) histories)))
- (write-region (point-min) (point-max) nov-file nil 'silent)
- ;; Delete the unwanted entries in the alist.
- (setq gnus-agent-article-alist
- (sort gnus-agent-article-alist 'car-less-than-car))
- (let* ((alist gnus-agent-article-alist)
- (prev (cons nil alist))
- (first prev))
- (while (and alist
- (<= (caar alist) article))
- (if (or (not (cdar alist))
- (not (file-exists-p
- (gnus-agent-article-name
- (number-to-string
- (caar alist))
- group))))
- (setcdr prev (setq alist (cdr alist)))
- (setq prev alist
- alist (cdr alist))))
- (setq gnus-agent-article-alist (cdr first)))
- (gnus-agent-save-alist group))
- expiry-hashtb)
- (set-buffer history)
- (setq histories (nreverse (sort histories '<)))
- (while histories
- (goto-char (pop histories))
- (gnus-delete-line))
- (gnus-agent-save-history)
- (gnus-agent-close-history))
- (gnus-message 4 "Expiry...done")))))
+ (when (file-exists-p (gnus-agent-lib-file "active"))
+ (with-temp-buffer
+ (insert-file-contents (gnus-agent-lib-file "active"))
+ (gnus-active-to-gnus-format
+ gnus-command-method
+ (setq orig (gnus-make-hashtable
+ (count-lines (point-min) (point-max))))))
+ (let ((expiry-hashtb (gnus-make-hashtable 1023)))
+ (gnus-agent-open-history)
+ (set-buffer
+ (setq gnus-agent-current-history
+ (setq history (gnus-agent-history-buffer))))
+ (goto-char (point-min))
+ (when (> (buffer-size) 1)
+ (goto-char (point-min))
+ (while (not (eobp))
+ (skip-chars-forward "^\t")
+ (if (> (read (current-buffer)) day)
+ ;; New article; we don't expire it.
+ (forward-line 1)
+ ;; Old article. Schedule it for possible nuking.
+ (while (not (eolp))
+ (setq sym (let ((obarray expiry-hashtb))
+ (read (current-buffer))))
+ (if (boundp sym)
+ (set sym (cons (cons (read (current-buffer)) (point))
+ (symbol-value sym)))
+ (set sym (list (cons (read (current-buffer)) (point)))))
+ (skip-chars-forward " "))
+ (forward-line 1)))
+ ;; We now have all articles that can possibly be expired.
+ (mapatoms
+ (lambda (sym)
+ (setq group (symbol-name sym)
+ articles (sort (symbol-value sym) 'car-less-than-car)
+ low (car (gnus-active group))
+ info (gnus-get-info group)
+ unreads (ignore-errors
+ (gnus-list-of-unread-articles group))
+ marked (nconc
+ (gnus-uncompress-range
+ (cdr (assq 'tick (gnus-info-marks info))))
+ (gnus-uncompress-range
+ (cdr (assq 'dormant
+ (gnus-info-marks info)))))
+ nov-file (gnus-agent-article-name ".overview" group)
+ lowest nil
+ highest nil)
+ (gnus-agent-load-alist group)
+ (gnus-message 5 "Expiring articles in %s" group)
+ (set-buffer overview)
+ (erase-buffer)
+ (when (file-exists-p nov-file)
+ (nnheader-insert-file-contents nov-file))
+ (goto-char (point-min))
+ (setq article 0)
+ (while (setq elem (pop articles))
+ (setq article (car elem))
+ (when (or (null low)
+ (< article low)
+ gnus-agent-expire-all
+ (and (not (memq article unreads))
+ (not (memq article marked))))
+ ;; Find and nuke the NOV line.
+ (while (and (not (eobp))
+ (or (not (numberp
+ (setq art (read (current-buffer)))))
+ (< art article)))
+ (if (file-exists-p
+ (gnus-agent-article-name
+ (number-to-string art) group))
+ (progn
+ (unless lowest
+ (setq lowest art))
+ (setq highest art)
+ (forward-line 1))
+ ;; Remove old NOV lines that have no articles.
+ (gnus-delete-line)))
+ (if (or (eobp)
+ (/= art article))
+ (beginning-of-line)
+ (gnus-delete-line))
+ ;; Nuke the article.
+ (when (file-exists-p
+ (setq file (gnus-agent-article-name
+ (number-to-string article)
+ group)))
+ (delete-file file))
+ ;; Schedule the history line for nuking.
+ (push (cdr elem) histories)))
+ (gnus-make-directory (file-name-directory nov-file))
+ (let ((coding-system-for-write
+ gnus-agent-file-coding-system))
+ (write-region (point-min) (point-max) nov-file nil 'silent))
+ ;; Delete the unwanted entries in the alist.
+ (setq gnus-agent-article-alist
+ (sort gnus-agent-article-alist 'car-less-than-car))
+ (let* ((alist gnus-agent-article-alist)
+ (prev (cons nil alist))
+ (first prev)
+ expired)
+ (while (and alist
+ (<= (caar alist) article))
+ (if (or (not (cdar alist))
+ (not (file-exists-p
+ (gnus-agent-article-name
+ (number-to-string
+ (caar alist))
+ group))))
+ (progn
+ (push (caar alist) expired)
+ (setcdr prev (setq alist (cdr alist))))
+ (setq prev alist
+ alist (cdr alist))))
+ (setq gnus-agent-article-alist (cdr first))
+ (gnus-agent-save-alist group)
+ ;; Mark all articles up to the first article
+ ;; in `gnus-article-alist' as read.
+ (when (and info (caar gnus-agent-article-alist))
+ (setcar (nthcdr 2 info)
+ (gnus-range-add
+ (nth 2 info)
+ (cons 1 (- (caar gnus-agent-article-alist) 1)))))
+ ;; Maybe everything has been expired from `gnus-article-alist'
+ ;; and so the above marking as read could not be conducted,
+ ;; or there are expired article within the range of the alist.
+ (when (and info
+ expired
+ (or (not (caar gnus-agent-article-alist))
+ (> (car expired)
+ (caar gnus-agent-article-alist))))
+ (setcar (nthcdr 2 info)
+ (gnus-add-to-range
+ (nth 2 info)
+ (nreverse expired))))
+ (gnus-dribble-enter
+ (concat "(gnus-group-set-info '"
+ (gnus-prin1-to-string info)
+ ")")))
+ (when lowest
+ (if (gnus-gethash group orig)
+ (setcar (gnus-gethash group orig) lowest)
+ (gnus-sethash group (cons lowest highest) orig))))
+ expiry-hashtb)
+ (set-buffer history)
+ (setq histories (nreverse (sort histories '<)))
+ (while histories
+ (goto-char (pop histories))
+ (gnus-delete-line))
+ (gnus-agent-save-history)
+ (gnus-agent-close-history)
+ (gnus-write-active-file
+ (gnus-agent-lib-file "active") orig))
+ (gnus-message 4 "Expiry...done")))))))
;;;###autoload
(defun gnus-agent-batch ()
projects / elisp / gnus.git- / blobdiff