cgit.sxemacs.org Git - gnus/blob - lisp/nnvirtual.el

   1 ;;;; nnvirtual.el --- virtual newsgroups access for (ding) Gnus
   2 ;; Copyright (C) 1994,95 Free Software Foundation, Inc.
   3
   4 ;; Author: Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
   5 ;;      Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
   6 ;; Keywords: news
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to
  22 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23
  24 ;;; Commentary:
  25
  26 ;; The other access methods (nntp, nnspool, etc) are general news
  27 ;; access methods. This module relies on Gnus and can not be used
  28 ;; separately.
  29
  30 ;;; Code:
  31
  32 (require 'nntp)
  33 (require 'nnheader)
  34 (require 'gnus)
  35
  36 \f
  37
  38 (defconst nnvirtual-version "nnvirtual 0.0"
  39   "Version number of this version of nnvirtual.")
  40
  41 (defvar nnvirtual-group-alist nil)
  42 (defvar nnvirtual-current-group nil)
  43 (defvar nnvirtual-current-groups nil)
  44 (defvar nnvirtual-current-mapping nil)
  45
  46 (defvar nnvirtual-do-not-open nil)
  47
  48 (defvar nnvirtual-status-string "")
  49
  50 \f
  51
  52 ;;; Interface functions.
  53
  54 (defun nnvirtual-retrieve-headers (sequence &optional newsgroup server)
  55   "Retrieve the headers for the articles in SEQUENCE."
  56   (nnvirtual-possibly-change-newsgroups newsgroup server t)
  57   (save-excursion
  58     (set-buffer (get-buffer-create "*virtual headers*"))
  59     (buffer-disable-undo (current-buffer))
  60     (erase-buffer)
  61     (let ((map nnvirtual-current-mapping)
  62           (offset 0)
  63           articles beg group active top article result prefix)
  64       (while sequence
  65         (while (< (car (car map)) (car sequence))
  66           (setq offset (car (car map)))
  67           (setq map (cdr map)))
  68         (setq top (car (car map)))
  69         (setq group (nth 1 (car map)))
  70         (setq prefix (gnus-group-real-prefix group))
  71         (setq active (nth 2 (car map)))
  72         (setq articles nil)
  73         (while (and sequence (<= (car sequence) top))
  74           (setq articles (cons (- (+ active (car sequence)) offset) articles))
  75           (setq sequence (cdr sequence)))
  76         (setq articles (nreverse articles))
  77         (if (and articles
  78                  (setq result (gnus-retrieve-headers articles group)))
  79             (save-excursion
  80               (set-buffer nntp-server-buffer)
  81               ;; If we got HEAD headers, we convert them into NOV
  82               ;; headers. This is slow, inefficient and, come to think
  83               ;; of it, downright evil. So sue me. I couldn't be
  84               ;; bothered to write a header parse routine that could
  85               ;; parse a mixed HEAD/NOV buffer.
  86               (and (eq result 'headers) (nnvirtual-convert-headers))
  87               (goto-char (point-min))
  88               (while (not (eobp))
  89                 (setq beg (point))
  90                 (setq article (read nntp-server-buffer))
  91                 (delete-region beg (point))
  92                 (insert (int-to-string (+ (- article active) offset)))
  93                 (beginning-of-line)
  94                 (looking-at "[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t")
  95                 (goto-char (match-end 0))
  96                 (or (search-forward
  97                      "\t" (save-excursion (end-of-line) (point)) t)
  98                     (end-of-line))
  99                 (while (= (char-after (1- (point))) ? )
 100                   (forward-char -1)
 101                   (delete-char 1))
 102                 (if (eolp)
 103                     (progn
 104                       (end-of-line)
 105                       (or (= (char-after (1- (point))) ?\t)
 106                           (insert ?\t))
 107                       (insert (format "Xref: %s %s:%d\t" (system-name)
 108                                       group article)))
 109                   (if (not (string= "" prefix))
 110                       (while (re-search-forward
 111                               "[^ ]+:[0-9]+"
 112                               (save-excursion (end-of-line) (point)) t)
 113                         (save-excursion
 114                           (goto-char (match-beginning 0))
 115                           (insert prefix))))
 116                   (end-of-line)
 117                   (or (= (char-after (1- (point))) ?\t)
 118                       (insert ?\t)))
 119                 (forward-line 1))))
 120         (goto-char (point-max))
 121         (insert-buffer-substring nntp-server-buffer))
 122       ;; The headers are ready for reading, so they are inserted into
 123       ;; the nntp-server-buffer, which is where Gnus expects to find
 124       ;; them.
 125       (prog1
 126           (save-excursion
 127             (set-buffer nntp-server-buffer)
 128             (erase-buffer)
 129             (insert-buffer-substring "*virtual headers*")
 130             'nov)
 131         (kill-buffer (current-buffer))))))
 132
 133 (defun nnvirtual-open-server (newsgroups &optional something)
 134   "Open a virtual newsgroup that contains NEWSGROUPS."
 135   (nnheader-init-server-buffer))
 136
 137 (defun nnvirtual-close-server (&rest dum)
 138   "Close news server."
 139   t)
 140
 141 (defun nnvirtual-server-opened (&optional server)
 142   "Return server process status, T or NIL.
 143 If the stream is opened, return T, otherwise return NIL."
 144   (and nntp-server-buffer
 145        (get-buffer nntp-server-buffer)))
 146
 147 (defun nnvirtual-status-message (&optional server)
 148   "Return server status response as string."
 149   nnvirtual-status-string)
 150
 151 (defun nnvirtual-request-article (article &optional newsgroup server buffer)
 152   "Select article by message number."
 153   (nnvirtual-possibly-change-newsgroups newsgroup server t)
 154   (and (numberp article)
 155        (let ((map nnvirtual-current-mapping)
 156              (offset 0))
 157          (while (< (car (car map)) article)
 158            (setq offset (car (car map)))
 159            (setq map (cdr map)))
 160          (gnus-request-group (nth 1 (car map)) t)
 161          (gnus-request-article (- (+ (nth 2 (car map)) article) offset)
 162                                (nth 1 (car map)) buffer))))
 163
 164 (defun nnvirtual-request-group (group &optional server dont-check)
 165   "Make GROUP the current newsgroup."
 166   (nnvirtual-possibly-change-newsgroups group server dont-check)
 167   (if (not dont-check)
 168       (let ((map nnvirtual-current-mapping))
 169         (while (cdr map)
 170           (setq map (cdr map)))
 171         (save-excursion
 172           (set-buffer nntp-server-buffer)
 173           (erase-buffer)
 174           (insert (format "211 %d 1 %d %s\n" (car (car map))
 175                           (car (car map)) group)))))
 176   t)
 177
 178 (defun nnvirtual-close-group (group &optional server)
 179   (nnvirtual-possibly-change-newsgroups group server t)
 180   (nnvirtual-update-marked)
 181   (setq nnvirtual-current-group nil
 182         nnvirtual-current-groups nil
 183         nnvirtual-current-mapping nil)
 184   (setq nnvirtual-group-alist
 185         (delq (assoc group nnvirtual-group-alist) nnvirtual-group-alist)))
 186
 187 (defun nnvirtual-request-list (&optional server)
 188   (setq nnvirtual-status-string "nnvirtual: LIST is not implemented.")
 189   nil)
 190
 191 (defun nnvirtual-request-newgroups (date &optional server)
 192   "List new groups."
 193   (setq nnvirtual-status-string "NEWGROUPS is not supported.")
 194   nil)
 195
 196 (defun nnvirtual-request-list-newsgroups (&optional server)
 197   (setq nnvirtual-status-string
 198         "nnvirtual: LIST NEWSGROUPS is not implemented.")
 199   nil)
 200
 201 (fset 'nnvirtual-request-post 'nntp-request-post)
 202
 203 (fset 'nnvirtual-request-post-buffer 'nntp-request-post-buffer)
 204
 205 \f
 206 ;;; Internal functions.
 207
 208 ;; Convert HEAD headers into NOV headers.
 209 (defun nnvirtual-convert-headers ()
 210   (save-excursion
 211     (set-buffer nntp-server-buffer)
 212     (let* ((gnus-newsgroup-dependencies (make-vector 100 0))
 213            (headers (gnus-get-newsgroup-headers))
 214            header)
 215       (erase-buffer)
 216       (while headers
 217         (setq header (car headers)
 218               headers (cdr headers))
 219         (insert (int-to-string (header-number header)) "\t"
 220                 (or (header-subject header) "") "\t"
 221                 (or (header-from header) "") "\t"
 222                 (or (header-date header) "") "\t"
 223                 (or (header-id header) "") "\t"
 224                 (or (header-references header) "") "\t"
 225                 (int-to-string (or (header-chars header) 0)) "\t"
 226                 (int-to-string (or (header-lines header) 0)) "\t"
 227                 (if (header-xref header)
 228                     (concat "Xref: " (header-xref header) "\t")
 229                   "") "\n")))))
 230
 231 (defun nnvirtual-possibly-change-newsgroups (group regexp &optional check)
 232   (let ((inf t))
 233     (or (not group)
 234         (and nnvirtual-current-group
 235              (string= group nnvirtual-current-group))
 236         (and (setq inf (assoc group nnvirtual-group-alist))
 237              (string= (nth 3 inf) regexp)
 238              (progn
 239                (setq nnvirtual-current-group (car inf))
 240                (setq nnvirtual-current-groups (nth 1 inf))
 241                (setq nnvirtual-current-mapping (nth 2 inf)))))
 242     (if (or (not check) (not inf))
 243         (progn
 244           (and inf (setq nnvirtual-group-alist
 245                          (delq inf nnvirtual-group-alist)))
 246           (setq nnvirtual-current-mapping nil)
 247           (setq nnvirtual-current-group group)
 248           (let ((newsrc gnus-newsrc-assoc))
 249             (setq nnvirtual-current-groups nil)
 250             (while newsrc
 251               (and (string-match regexp (car (car newsrc)))
 252                    (setq nnvirtual-current-groups
 253                          (cons (car (car newsrc)) nnvirtual-current-groups)))
 254               (setq newsrc (cdr newsrc))))
 255           (if nnvirtual-current-groups
 256               (progn
 257                 (nnvirtual-create-mapping group)
 258                 (setq nnvirtual-group-alist
 259                       (cons (list group nnvirtual-current-groups
 260                                   nnvirtual-current-mapping regexp)
 261                             nnvirtual-group-alist)))
 262             (setq nnvirtual-status-string
 263                   (format
 264                    "nnvirtual: No newsgroups for this virtual newsgroup"))))))
 265   nnvirtual-current-groups)
 266
 267 (defun nnvirtual-create-mapping (group)
 268   (let* ((group (gnus-group-prefixed-name group (list 'nnvirtual "")))
 269          (info (nth 2 (gnus-gethash group gnus-newsrc-hashtb)))
 270          (groups nnvirtual-current-groups)
 271          (i 1)
 272          (total 0)
 273          (offset 0)
 274          reads unread igroup itotal itreads ireads)
 275     ;; The virtual group doesn't exist. (?)
 276     (or info (error "No such group: %s" group))
 277     (setq nnvirtual-current-mapping nil)
 278     (while groups
 279       ;; Added by Sudish Joseph <joseph@cis.ohio-state.edu>.
 280       (setq igroup (car groups))
 281       (let ((info (nth 2 (gnus-gethash igroup gnus-newsrc-hashtb)))
 282             (active (gnus-gethash igroup gnus-active-hashtb)))
 283         ;; See if the group has had its active list read this session
 284         ;; if not, we do it now.
 285         (if (null active)
 286             (if (gnus-activate-newsgroup igroup)
 287                 (progn
 288                   (gnus-get-unread-articles-in-group
 289                    info (gnus-gethash igroup gnus-active-hashtb))
 290                   (setq active (gnus-gethash igroup gnus-active-hashtb)))
 291               (message "Couldn't open component group %s" igroup)
 292               (ding)))
 293         (if (null active)
 294             ()
 295           ;; And then we do the mapping for this component group. If
 296           ;; you feel tempte to cast your eyes to the soup below -
 297           ;; don't. It'll hurt your soul. Suffice to say that it
 298           ;; assigns ranges of nnvirtual article numbers to the
 299           ;; different component groups. To get the article number
 300           ;; from the nnvirtual number, one does something like
 301           ;; (+ (- number offset) (car active)), where `offset' is the
 302           ;; slice the mess below assigns, and active is the lowest
 303           ;; active article in the component group.
 304           (setq itotal (1+ (- (cdr active) (car active))))
 305           (if (setq ireads (nth 2 info))
 306               (let ((itreads
 307                      (if (atom (car ireads))
 308                          (setq ireads (list (cons (car ireads) (cdr ireads))))
 309                        (setq ireads (copy-alist ireads)))))
 310                 (if (< (cdr (car ireads)) (car active))
 311                     (setq ireads (setq itreads (cdr ireads))))
 312                 (if (and ireads (< (car (car ireads)) (car active)))
 313                     (setcar (car ireads) (1+ (car active))))
 314                 (while itreads
 315                   (setcar (car itreads)
 316                           (+ (- (car (car itreads)) (car active)) offset))
 317                   (setcdr (car itreads)
 318                           (+ (- (cdr (car itreads)) (car active)) offset))
 319                   (setq itreads (cdr itreads)))
 320                 (setq reads (nconc reads ireads))))
 321           (setq offset (+ offset (1- itotal)))
 322           (setq nnvirtual-current-mapping
 323                 (cons (list offset igroup (car active))
 324                       nnvirtual-current-mapping)))
 325         (setq groups (cdr groups))))
 326     (setq nnvirtual-current-mapping
 327           (nreverse nnvirtual-current-mapping))
 328     (gnus-sethash group (cons 1 offset) gnus-active-hashtb)
 329     (setcar (nthcdr 2 info) reads)
 330
 331     ;; Then we deal with the marks.
 332     (let ((map nnvirtual-current-mapping)
 333           (marks '(tick dormant reply expire score))
 334           (offset 0)
 335           tick dormant reply expire score marked active)
 336       (while map
 337         (setq igroup (nth 1 (car map)))
 338         (setq active (nth 2 (car map)))
 339         (setq marked (nth 3 (nth 2 (gnus-gethash igroup gnus-newsrc-hashtb))))
 340         (let ((m marks))
 341           (while m
 342             (and (assq (car m) marked)
 343                  (set (car m)
 344                       (nconc (mapcar
 345                               (lambda (art)
 346                                 (if (numberp art)
 347                                     (+ (- art active) offset)
 348                                   (cons (+ (- (car art) active) offset)
 349                                         (cdr art))))
 350                               (cdr (assq (car m) marked)))
 351                              (symbol-value (car m)))))
 352             (setq m (cdr m))))
 353         (setq offset (car (car map)))
 354         (setq map (cdr map)))
 355       ;; Put the list of marked articles in the info of the virtual group.
 356       (let ((m marks)
 357             marked)
 358         (while m
 359           (and (symbol-value (car m))
 360                (setq marked (cons (cons (car m) (symbol-value (car m)))
 361                                   marked)))
 362           (setq m (cdr m)))
 363         (if (nthcdr 3 info)
 364             (setcar (nthcdr 3 info) marked)
 365           (setcdr (nthcdr 2 info) (list marked)))))))
 366
 367 (defun nnvirtual-update-marked ()
 368   (let ((mark-lists '((gnus-newsgroup-marked . tick)
 369                       (gnus-newsgroup-dormant . dormant)
 370                       (gnus-newsgroup-expirable . expire)
 371                       (gnus-newsgroup-replied . reply)))
 372         marks art-group group-alist g)
 373     (while mark-lists
 374       (setq marks (symbol-value (car (car mark-lists))))
 375       (while marks
 376         (setq art-group (nnvirtual-art-group (car marks)))
 377         (if (setq g (assoc (car art-group) group-alist))
 378             (nconc g (list (cdr art-group)))
 379           (setq group-alist (cons (list (car art-group) (cdr art-group))
 380                                   group-alist)))
 381         (setq marks (cdr marks)))
 382       (while group-alist
 383         (gnus-add-marked-articles
 384          (car (car group-alist)) (cdr (car mark-lists))
 385          (cdr (car group-alist)) nil t)
 386         (gnus-group-update-group (car (car group-alist)) t)
 387         (setq group-alist (cdr group-alist)))
 388       (setq mark-lists (cdr mark-lists)))))
 389
 390 (defun nnvirtual-art-group (article)
 391   (let ((map nnvirtual-current-mapping)
 392         (offset 0))
 393     (while (< (car (car map)) (if (numberp article) article (car article)))
 394       (setq offset (car (car map))
 395             map (cdr map)))
 396     (cons (nth 1 (car map))
 397           (if (numberp article)
 398               (- (+ article (nth 2 (car map))) offset)
 399             (cons (- (+ (car article) (nth 2 (car map))) offset)
 400                   (cdr article))))))
 401
 402 (provide 'nnvirtual)
 403
 404 ;;; nnvirtual.el ends here