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

   1 ;;; gnus-soup.el --- SOUP packet writing support for Gnus
   2 ;; Copyright (C) 1995,96,97,98,99 Free Software Foundation, Inc.
   3
   4 ;; Author: Per Abrahamsen <abraham@iesd.auc.dk>
   5 ;;      Lars Magne Ingebrigtsen <larsi@gnus.org>
   6 ;; Keywords: news, mail
   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 the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  24
  25 ;;; Commentary:
  26
  27 ;;; Code:
  28
  29 (eval-when-compile (require 'cl))
  30
  31 (require 'gnus)
  32 (require 'gnus-art)
  33 (require 'message)
  34 (require 'gnus-start)
  35 (require 'gnus-range)
  36
  37 ;;; User Variables:
  38
  39 (defvar gnus-soup-directory (nnheader-concat gnus-home-directory "SoupBrew/")
  40   "*Directory containing an unpacked SOUP packet.")
  41
  42 (defvar gnus-soup-replies-directory
  43   (nnheader-concat gnus-soup-directory "SoupReplies/")
  44   "*Directory where Gnus will do processing of replies.")
  45
  46 (defvar gnus-soup-prefix-file "gnus-prefix"
  47   "*Name of the file where Gnus stores the last used prefix.")
  48
  49 (defvar gnus-soup-packer "tar cf - %s | gzip > $HOME/Soupout%d.tgz"
  50   "Format string command for packing a SOUP packet.
  51 The SOUP files will be inserted where the %s is in the string.
  52 This string MUST contain both %s and %d.  The file number will be
  53 inserted where %d appears.")
  54
  55 (defvar gnus-soup-unpacker "gunzip -c %s | tar xvf -"
  56   "*Format string command for unpacking a SOUP packet.
  57 The SOUP packet file name will be inserted at the %s.")
  58
  59 (defvar gnus-soup-packet-directory gnus-home-directory
  60   "*Where gnus-soup will look for REPLIES packets.")
  61
  62 (defvar gnus-soup-packet-regexp "Soupin"
  63   "*Regular expression matching SOUP REPLIES packets in `gnus-soup-packet-directory'.")
  64
  65 (defvar gnus-soup-ignored-headers "^Xref:"
  66   "*Regexp to match headers to be removed when brewing SOUP packets.")
  67
  68 ;;; Internal Variables:
  69
  70 (defvar gnus-soup-encoding-type ?u
  71   "*Soup encoding type.
  72 `u' is USENET news format, `m' is Unix mbox format, and `M' is MMDF mailbox
  73 format.")
  74
  75 (defvar gnus-soup-index-type ?c
  76   "*Soup index type.
  77 `n' means no index file and `c' means standard Cnews overview
  78 format.")
  79
  80 (defvar gnus-soup-areas nil)
  81 (defvar gnus-soup-last-prefix nil)
  82 (defvar gnus-soup-prev-prefix nil)
  83 (defvar gnus-soup-buffers nil)
  84
  85 ;;; Access macros:
  86
  87 (defmacro gnus-soup-area-prefix (area)
  88   `(aref ,area 0))
  89 (defmacro gnus-soup-set-area-prefix (area prefix)
  90   `(aset ,area 0 ,prefix))
  91 (defmacro gnus-soup-area-name (area)
  92   `(aref ,area 1))
  93 (defmacro gnus-soup-area-encoding (area)
  94   `(aref ,area 2))
  95 (defmacro gnus-soup-area-description (area)
  96   `(aref ,area 3))
  97 (defmacro gnus-soup-area-number (area)
  98   `(aref ,area 4))
  99 (defmacro gnus-soup-area-set-number (area value)
 100   `(aset ,area 4 ,value))
 101
 102 (defmacro gnus-soup-encoding-format (encoding)
 103   `(aref ,encoding 0))
 104 (defmacro gnus-soup-encoding-index (encoding)
 105   `(aref ,encoding 1))
 106 (defmacro gnus-soup-encoding-kind (encoding)
 107   `(aref ,encoding 2))
 108
 109 (defmacro gnus-soup-reply-prefix (reply)
 110   `(aref ,reply 0))
 111 (defmacro gnus-soup-reply-kind (reply)
 112   `(aref ,reply 1))
 113 (defmacro gnus-soup-reply-encoding (reply)
 114   `(aref ,reply 2))
 115
 116 ;;; Commands:
 117
 118 (defun gnus-soup-send-replies ()
 119   "Unpack and send all replies in the reply packet."
 120   (interactive)
 121   (let ((packets (directory-files
 122                   gnus-soup-packet-directory t gnus-soup-packet-regexp)))
 123     (while packets
 124       (when (gnus-soup-send-packet (car packets))
 125         (delete-file (car packets)))
 126       (setq packets (cdr packets)))))
 127
 128 (defun gnus-soup-add-article (n)
 129   "Add the current article to SOUP packet.
 130 If N is a positive number, add the N next articles.
 131 If N is a negative number, add the N previous articles.
 132 If N is nil and any articles have been marked with the process mark,
 133 move those articles instead."
 134   (interactive "P")
 135   (let* ((articles (gnus-summary-work-articles n))
 136          (tmp-buf (gnus-get-buffer-create "*soup work*"))
 137          (area (gnus-soup-area gnus-newsgroup-name))
 138          (prefix (gnus-soup-area-prefix area))
 139          headers)
 140     (buffer-disable-undo tmp-buf)
 141     (save-excursion
 142       (while articles
 143         ;; Put the article in a buffer.
 144         (set-buffer tmp-buf)
 145         (when (gnus-request-article-this-buffer
 146                (car articles) gnus-newsgroup-name)
 147           (setq headers (nnheader-parse-head t))
 148           (save-restriction
 149             (message-narrow-to-head)
 150             (message-remove-header gnus-soup-ignored-headers t))
 151           (gnus-soup-store gnus-soup-directory prefix headers
 152                            gnus-soup-encoding-type
 153                            gnus-soup-index-type)
 154           (gnus-soup-area-set-number
 155            area (1+ (or (gnus-soup-area-number area) 0))))
 156         ;; Mark article as read.
 157         (set-buffer gnus-summary-buffer)
 158         (gnus-summary-remove-process-mark (car articles))
 159         (gnus-summary-mark-as-read (car articles) gnus-souped-mark)
 160         (setq articles (cdr articles)))
 161       (kill-buffer tmp-buf))
 162     (gnus-soup-save-areas)
 163     (gnus-set-mode-line 'summary)))
 164
 165 (defun gnus-soup-pack-packet ()
 166   "Make a SOUP packet from the SOUP areas."
 167   (interactive)
 168   (gnus-soup-read-areas)
 169   (if (file-exists-p gnus-soup-directory)
 170       (if (directory-files gnus-soup-directory nil "\\.MSG$")
 171           (gnus-soup-pack gnus-soup-directory gnus-soup-packer)
 172         (message "No files to pack."))
 173     (message "No such directory: %s" gnus-soup-directory)))
 174
 175 (defun gnus-group-brew-soup (n)
 176   "Make a soup packet from the current group.
 177 Uses the process/prefix convention."
 178   (interactive "P")
 179   (let ((groups (gnus-group-process-prefix n)))
 180     (while groups
 181       (gnus-group-remove-mark (car groups))
 182       (gnus-soup-group-brew (car groups) t)
 183       (setq groups (cdr groups)))
 184     (gnus-soup-save-areas)))
 185
 186 (defun gnus-brew-soup (&optional level)
 187   "Go through all groups on LEVEL or less and make a soup packet."
 188   (interactive "P")
 189   (let ((level (or level gnus-level-subscribed))
 190         (newsrc (cdr gnus-newsrc-alist)))
 191     (while newsrc
 192       (when (<= (nth 1 (car newsrc)) level)
 193         (gnus-soup-group-brew (caar newsrc) t))
 194       (setq newsrc (cdr newsrc)))
 195     (gnus-soup-save-areas)))
 196
 197 ;;;###autoload
 198 (defun gnus-batch-brew-soup ()
 199   "Brew a SOUP packet from groups mention on the command line.
 200 Will use the remaining command line arguments as regular expressions
 201 for matching on group names.
 202
 203 For instance, if you want to brew on all the nnml groups, as well as
 204 groups with \"emacs\" in the name, you could say something like:
 205
 206 $ emacs -batch -f gnus-batch-brew-soup ^nnml \".*emacs.*\"
 207
 208 Note -- this function hasn't been implemented yet."
 209   (interactive)
 210   nil)
 211
 212 ;;; Internal Functions:
 213
 214 ;; Store the current buffer.
 215 (defun gnus-soup-store (directory prefix headers format index)
 216   ;; Create the directory, if needed.
 217   (gnus-make-directory directory)
 218   (let* ((msg-buf (nnheader-find-file-noselect
 219                    (concat directory prefix ".MSG")))
 220          (idx-buf (if (= index ?n)
 221                       nil
 222                     (nnheader-find-file-noselect
 223                      (concat directory prefix ".IDX"))))
 224          (article-buf (current-buffer))
 225          from head-line beg type)
 226     (setq gnus-soup-buffers (cons msg-buf (delq msg-buf gnus-soup-buffers)))
 227     (buffer-disable-undo msg-buf)
 228     (when idx-buf
 229       (push idx-buf gnus-soup-buffers)
 230       (buffer-disable-undo idx-buf))
 231     (save-excursion
 232       ;; Make sure the last char in the buffer is a newline.
 233       (goto-char (point-max))
 234       (unless (= (current-column) 0)
 235         (insert "\n"))
 236       ;; Find the "from".
 237       (goto-char (point-min))
 238       (setq from
 239             (gnus-mail-strip-quoted-names
 240              (or (mail-fetch-field "from")
 241                  (mail-fetch-field "really-from")
 242                  (mail-fetch-field "sender"))))
 243       (goto-char (point-min))
 244       ;; Depending on what encoding is supposed to be used, we make
 245       ;; a soup header.
 246       (setq head-line
 247             (cond
 248              ((or (= gnus-soup-encoding-type ?u)
 249                   (= gnus-soup-encoding-type ?n)) ;;Gnus back compatibility.
 250               (format "#! rnews %d\n" (buffer-size)))
 251              ((= gnus-soup-encoding-type ?m)
 252               (while (search-forward "\nFrom " nil t)
 253                 (replace-match "\n>From " t t))
 254               (concat "From " (or from "unknown")
 255                       " " (current-time-string) "\n"))
 256              ((= gnus-soup-encoding-type ?M)
 257               "\^a\^a\^a\^a\n")
 258              (t (error "Unsupported type: %c" gnus-soup-encoding-type))))
 259       ;; Insert the soup header and the article in the MSG buf.
 260       (set-buffer msg-buf)
 261       (goto-char (point-max))
 262       (insert head-line)
 263       (setq beg (point))
 264       (insert-buffer-substring article-buf)
 265       ;; Insert the index in the IDX buf.
 266       (cond ((= index ?c)
 267              (set-buffer idx-buf)
 268              (gnus-soup-insert-idx beg headers))
 269             ((/= index ?n)
 270              (error "Unknown index type: %c" type)))
 271       ;; Return the MSG buf.
 272       msg-buf)))
 273
 274 (defun gnus-soup-group-brew (group &optional not-all)
 275   "Enter GROUP and add all articles to a SOUP package.
 276 If NOT-ALL, don't pack ticked articles."
 277   (let ((gnus-expert-user t)
 278         (gnus-large-newsgroup nil)
 279         (entry (gnus-gethash group gnus-newsrc-hashtb)))
 280     (when (or (null entry)
 281               (eq (car entry) t)
 282               (and (car entry)
 283                    (> (car entry) 0))
 284               (and (not not-all)
 285                    (gnus-range-length (cdr (assq 'tick (gnus-info-marks
 286                                                         (nth 2 entry)))))))
 287       (when (gnus-summary-read-group group nil t)
 288         (setq gnus-newsgroup-processable
 289               (reverse
 290                (if (not not-all)
 291                    (append gnus-newsgroup-marked gnus-newsgroup-unreads)
 292                  gnus-newsgroup-unreads)))
 293         (gnus-soup-add-article nil)
 294         (gnus-summary-exit)))))
 295
 296 (defun gnus-soup-insert-idx (offset header)
 297   ;; [number subject from date id references chars lines xref]
 298   (goto-char (point-max))
 299   (insert
 300    (format "%d\t%s\t%s\t%s\t%s\t%s\t%d\t%s\t\t\n"
 301            offset
 302            (or (mail-header-subject header) "(none)")
 303            (or (mail-header-from header) "(nobody)")
 304            (or (mail-header-date header) "")
 305            (or (mail-header-id header)
 306                (concat "soup-dummy-id-"
 307                        (mapconcat
 308                         (lambda (time) (int-to-string time))
 309                         (current-time) "-")))
 310            (or (mail-header-references header) "")
 311            (or (mail-header-chars header) 0)
 312            (or (mail-header-lines header) "0"))))
 313
 314 (defun gnus-soup-save-areas ()
 315   "Write all SOUP buffers."
 316   (interactive)
 317   (gnus-soup-write-areas)
 318   (save-excursion
 319     (let (buf)
 320       (while gnus-soup-buffers
 321         (setq buf (car gnus-soup-buffers)
 322               gnus-soup-buffers (cdr gnus-soup-buffers))
 323         (if (not (buffer-name buf))
 324             ()
 325           (set-buffer buf)
 326           (when (buffer-modified-p)
 327             (save-buffer))
 328           (kill-buffer (current-buffer)))))
 329     (gnus-soup-write-prefixes)))
 330
 331 (defun gnus-soup-write-prefixes ()
 332   (let ((prefixes gnus-soup-last-prefix)
 333         prefix)
 334     (save-excursion
 335       (gnus-set-work-buffer)
 336       (while (setq prefix (pop prefixes))
 337         (erase-buffer)
 338         (insert (format "(setq gnus-soup-prev-prefix %d)\n" (cdr prefix)))
 339         (let ((coding-system-for-write mm-text-coding-system))
 340           (gnus-write-buffer (concat (car prefix) gnus-soup-prefix-file)))))))
 341
 342 (defun gnus-soup-pack (dir packer)
 343   (let* ((files (mapconcat 'identity
 344                            '("AREAS" "*.MSG" "*.IDX" "INFO"
 345                              "LIST" "REPLIES" "COMMANDS" "ERRORS")
 346                            " "))
 347          (packer (if (< (string-match "%s" packer)
 348                         (string-match "%d" packer))
 349                      (format packer files
 350                              (string-to-int (gnus-soup-unique-prefix dir)))
 351                    (format packer
 352                            (string-to-int (gnus-soup-unique-prefix dir))
 353                            files)))
 354          (dir (expand-file-name dir)))