;;; nnvirtual.el --- virtual newsgroups access for Gnus
-;; Copyright (C) 1994,95,96,97 Free Software Foundation, Inc.
+;; Copyright (C) 1994,95,96,97,98,99 Free Software Foundation, Inc.
;; Author: David Moore <dmoore@ucsd.edu>
-;; Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
+;; Lars Magne Ingebrigtsen <larsi@gnus.org>
;; Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
;; Keywords: news
(require 'gnus-util)
(require 'gnus-start)
(require 'gnus-sum)
-(eval-when-compile (require 'cl))
+(require 'gnus-msg)
+(require 'cl)
(nnoo-declare nnvirtual)
-(defvoo nnvirtual-always-rescan nil
+(defvoo nnvirtual-always-rescan t
"*If non-nil, always scan groups for unread articles when entering a group.
If this variable is nil (which is the default) and you read articles
in a component group after the virtual group has been activated, the
(if buffer
(save-excursion
(set-buffer buffer)
- (gnus-request-article-this-buffer (cdr amap) cgroup))
+ ;; We bind this here to avoid double decoding.
+ (let ((gnus-article-decode-hook nil))
+ (gnus-request-article-this-buffer (cdr amap) cgroup)))
(gnus-request-article (cdr amap) cgroup))))))))
(setq nnvirtual-current-group nil)
(nnheader-report 'nnvirtual "No component groups in %s" group))
(t
+ (setq nnvirtual-current-group group)
(when (or (not dont-check)
nnvirtual-always-rescan)
- (nnvirtual-create-mapping))
- (setq nnvirtual-current-group group)
+ (nnvirtual-create-mapping)
+ (when nnvirtual-always-rescan
+ (nnvirtual-request-update-info
+ (nnvirtual-current-group)
+ (gnus-get-info (nnvirtual-current-group)))))
(nnheader-insert "211 %d 1 %d %s\n"
nnvirtual-mapping-len nnvirtual-mapping-len group))))
(deffoo nnvirtual-request-type (group &optional article)
(if (not article)
'unknown
- (let ((mart (nnvirtual-map-article article)))
- (when mart
- (gnus-request-type (car mart) (cdr mart))))))
+ (if (numberp article)
+ (let ((mart (nnvirtual-map-article article)))
+ (if mart
+ (gnus-request-type (car mart) (cdr mart))))
+ (gnus-request-type
+ nnvirtual-last-accessed-component-group nil))))
(deffoo nnvirtual-request-update-mark (group article mark)
(let* ((nart (nnvirtual-map-article article))
;; The component group might be a virtual group.
(nmark (gnus-request-update-mark cgroup (cdr nart) mark)))
(when (and nart
+ (memq mark gnus-auto-expirable-marks)
(= mark nmark)
(gnus-group-auto-expirable-p cgroup))
(setq mark gnus-expirable-mark)))
"Return the real group and article for virtual GROUP and ARTICLE."
(nnvirtual-map-article article))
+
+(deffoo nnvirtual-request-post (&optional server)
+ (if (not gnus-message-group-art)
+ (nnheader-report 'nnvirtual "Can't post to an nnvirtual group")
+ (let ((group (car (nnvirtual-find-group-art
+ (car gnus-message-group-art)
+ (cdr gnus-message-group-art)))))
+ (gnus-request-post (gnus-find-method-for-group group)))))
+
+
+(deffoo nnvirtual-request-expire-articles (articles group
+ &optional server force)
+ (nnvirtual-possibly-change-server server)
+ (setq nnvirtual-component-groups
+ (delete (nnvirtual-current-group) nnvirtual-component-groups))
+ (dolist (group nnvirtual-component-groups)
+ (gnus-group-expire-articles-1 group)))
+
\f
;;; Internal functions.
(insert "\t"))
;; Remove any spaces at the beginning of the Xref field.
- (while (= (char-after (1- (point))) ? )
+ (while (eq (char-after (1- (point))) ? )
(forward-char -1)
(delete-char 1))
(insert "Xref: " system-name " " group ":")
(princ article (current-buffer))
+ (insert " ")
;; If there were existing xref lines, clean them up to have the correct
;; component server prefix.
- (let ((xref-end (save-excursion
- (search-forward "\t" (gnus-point-at-eol) 'move)
- (point)))
- (len (length prefix)))
- (unless (= (point) xref-end)
+ (save-restriction
+ (narrow-to-region (point)
+ (or (search-forward "\t" (gnus-point-at-eol) t)
+ (gnus-point-at-eol)))
+ (goto-char (point-min))
+ (when (re-search-forward "Xref: *[^\n:0-9 ]+ *" nil t)
+ (replace-match "" t t))
+ (goto-char (point-min))
+ (when (re-search-forward
+ (concat (regexp-quote (gnus-group-real-name group)) ":[0-9]+")
+ nil t)
+ (replace-match "" t t))
+ (unless (= (point) (point-max))
(insert " ")
(when (not (string= "" prefix))
- (while (re-search-forward "[^ ]+:[0-9]+" xref-end t)
+ (while (re-search-forward "[^ ]+:[0-9]+" nil t)
(save-excursion
(goto-char (match-beginning 0))
- (insert prefix))
- (setq xref-end (+ xref-end len)))
- )))
+ (insert prefix))))))
;; Ensure a trailing \t.
(end-of-line)
- (or (= (char-after (1- (point))) ?\t)
+ (or (eq (char-after (1- (point))) ?\t)
(insert ?\t)))
(nnvirtual-partition-sequence
(gnus-list-of-unread-articles
(nnvirtual-current-group)))))
- (type-marks (mapcar (lambda (ml)
- (cons (car ml)
- (nnvirtual-partition-sequence (cdr ml))))
- (gnus-info-marks (gnus-get-info
- (nnvirtual-current-group)))))
+ (type-marks
+ (delq nil
+ (mapcar (lambda (ml)
+ (if (eq (car ml) 'score)
+ nil
+ (cons (car ml)
+ (nnvirtual-partition-sequence (cdr ml)))))
+ (gnus-info-marks (gnus-get-info
+ (nnvirtual-current-group))))))
mark type groups carticles info entry)
;; Ok, atomically move all of the (un)read info, clear any old
;; marks, and move all of the current marks. This way if someone
;; hits C-g, you won't leave the component groups in a half-way state.
- (gnus-atomic-progn
+ (progn
;; move (un)read
- (let ((gnus-newsgroup-active nil)) ;workaround guns-update-read-articles
+ ;; bind for workaround guns-update-read-articles
+ (let ((gnus-newsgroup-active nil))
(while (setq entry (pop unreads))
(gnus-update-read-articles (car entry) (cdr entry))))
(while groups
(when (and (setq info (gnus-get-info (pop groups)))
(gnus-info-marks info))
- (gnus-info-set-marks info nil)))
+ (gnus-info-set-marks
+ info
+ (if (assq 'score (gnus-info-marks info))
+ (list (assq 'score (gnus-info-marks info)))
+ nil))))
;; Ok, currently type-marks is an assq list with keys of a mark type,
;; with data of an assq list with keys of component group names
"Merge many sorted lists of numbers."
(if (null (cdr lists))
(car lists)
- (apply 'nnvirtual-merge-sorted-lists
- (merge 'list (car lists) (cadr lists) '<)
- (cddr lists))))
-
+ (sort (apply 'nconc lists) '<)))
;;; We map between virtual articles and real articles in a manner
(defun nnvirtual-reverse-map-article (group article)
"Return the virtual article number corresponding to the given component GROUP and ARTICLE."
- (let ((table nnvirtual-mapping-table)
- (group-pos 0)
- entry)
- (while (not (string= group (car (aref nnvirtual-mapping-offsets
+ (when (numberp article)
+ (let ((table nnvirtual-mapping-table)
+ (group-pos 0)
+ entry)
+ (while (not (string= group (car (aref nnvirtual-mapping-offsets
+ group-pos))))
+ (setq group-pos (1+ group-pos)))
+ (setq article (- article (cdr (aref nnvirtual-mapping-offsets
group-pos))))
- (setq group-pos (1+ group-pos)))
- (setq article (- article (cdr (aref nnvirtual-mapping-offsets
- group-pos))))
- (while (and table
- (> article (aref (car table) 0)))
- (setq table (cdr table)))
- (setq entry (car table))
- (when (and entry
- (> article 0)
- (< group-pos (aref entry 2))) ; article not out of range below
- (+ (aref entry 4)
- group-pos
- (* (- article (aref entry 1))
- (aref entry 2))
- 1))
- ))
-
-
-(defun nnvirtual-reverse-map-sequence (group articles)
+ (while (and table
+ (> article (aref (car table) 0)))
+ (setq table (cdr table)))
+ (setq entry (car table))
+ (when (and entry
+ (> article 0)
+ (< group-pos (aref entry 2))) ; article not out of range below
+ (+ (aref entry 4)
+ group-pos
+ (* (- article (aref entry 1))
+ (aref entry 2))
+ 1))
+ )))
+
+
+(defsubst nnvirtual-reverse-map-sequence (group articles)
"Return list of virtual article numbers for all ARTICLES in GROUP.
The ARTICLES should be sorted, and can be a compressed sequence.
If any of the article numbers has no corresponding virtual article,
(setq entry (assoc (car article) carticles))
(setcdr entry (cons (cdr article) (cdr entry))))
(setq i (1+ i))))
- (mapc '(lambda (x) (setcdr x (nreverse (cdr x))))
- carticles)
+ (mapcar (lambda (x) (setcdr x (nreverse (cdr x))))
+ carticles)
carticles))
gnus-article-mark-lists))
;; Remove any empty marks lists, and store.
- (setq nnvirtual-mapping-marks (delete-if-not 'cdr marks))
+ (setq nnvirtual-mapping-marks nil)
+ (while marks
+ (if (cdr (car marks))
+ (push (car marks) nnvirtual-mapping-marks))
+ (setq marks (cdr marks)))
;; We need to convert the unreads to reads. We compress the
;; sequence as we go, otherwise it could be huge.
projects / gnus / blobdiff