;;; gnus-soup.el --- SOUP packet writing support for Gnus
-;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995,96,97,98 Free Software Foundation, Inc.
;; Author: Per Abrahamsen <abraham@iesd.auc.dk>
+;; Lars Magne Ingebrigtsen <larsi@gnus.org>
;; Keywords: news, mail
;; This file is part of GNU Emacs.
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
-;; This file contain support for storing articles in SOUP format from
-;; within Gnus. Support for reading SOUP packets is provided in
-;; `nnsoup.el'.
-
-;; SOUP is a format for offline reading of news and mail. See the
-;; file `soup12.zip' in one of the Simtel mirrors
-;; (e.g. `ftp.funet.fi') for the specification of SOUP.
-
-;; Only a subset of the SOUP protocol is supported, and the minimal
-;; conformance requirements in the SOUP document is *not* meet.
-;; Most annoyingly, replying and posting are not supported.
-
-;; Insert
-;; (require 'gnus-soup)
-;; in your `.emacs' file to enable the SOUP support.
-
-;; Type `V o s' to add articles to the SOUP packet.
-;; Use a prefix argument or the process mark to add multiple articles.
-
-;; The variable `gnus-soup-directory' should point to the directory
-;; where you want to store the SOUP component files. You must
-;; manually `zip' the directory to generate a conforming SOUP packet.
-
-;; Add `nnsoup' to `gnus-secondary-select-methods' in order to read a
-;; SOUP packet. The variable `nnmail-directory' should point to the
-;; directory containing the unziped SOUP packet.
-
-;; Check out `uqwk' or `yarn' for two alterative solutions to
-;; generating or reading SOUP packages respectively, they should both
-;; be available at a Simtel mirror near you. There are plenty of
-;; other SOUP-aware programs available as well, look in the group
-;; `alt.usenet.offline-reader' and its FAQ for more information.
-
-;; Since `gnus-soup.el' does not fulfill the minimal conformance
-;; requirements, expect some problems when using other SOUP packeges.
-;; More importantly, the author haven't tested any of them.
-
;;; Code:
-(require 'gnus-msg)
+(eval-when-compile (require 'cl))
+
(require 'gnus)
+(require 'gnus-art)
+(require 'message)
+(require 'gnus-start)
+(require 'gnus-range)
;;; User Variables:
-(defvar gnus-soup-directory "~/SoupBrew/"
+(defvar gnus-soup-directory (nnheader-concat gnus-home-directory "SoupBrew/")
"*Directory containing an unpacked SOUP packet.")
-(defvar gnus-soup-replies-directory (concat gnus-soup-directory "SoupReplies/")
+(defvar gnus-soup-replies-directory
+ (nnheader-concat gnus-soup-directory "SoupReplies/")
"*Directory where Gnus will do processing of replies.")
(defvar gnus-soup-prefix-file "gnus-prefix"
(defvar gnus-soup-packer "tar cf - %s | gzip > $HOME/Soupout%d.tgz"
"Format string command for packing a SOUP packet.
The SOUP files will be inserted where the %s is in the string.
-This string MUST contain both %s and %d. The file number will be
+This string MUST contain both %s and %d. The file number will be
inserted where %d appears.")
(defvar gnus-soup-unpacker "gunzip -c %s | tar xvf -"
"*Format string command for unpacking a SOUP packet.
The SOUP packet file name will be inserted at the %s.")
-(defvar gnus-soup-packet-directory "~/"
+(defvar gnus-soup-packet-directory gnus-home-directory
"*Where gnus-soup will look for REPLIES packets.")
(defvar gnus-soup-packet-regexp "Soupin"
"*Regular expression matching SOUP REPLIES packets in `gnus-soup-packet-directory'.")
+(defvar gnus-soup-ignored-headers "^Xref:"
+ "*Regexp to match headers to be removed when brewing SOUP packets.")
+
;;; Internal Variables:
(defvar gnus-soup-encoding-type ?n
(defvar gnus-soup-index-type ?c
"*Soup index type.
`n' means no index file and `c' means standard Cnews overview
-format.")
-
-(defvar gnus-soup-group-type ?u
- "*Soup message area type.
-`u' is unknown, `m' is private mail, and `n' is news.
-Gnus will determine by itself what type to use in what group, so
-setting this variable won't do much.")
+format.")
(defvar gnus-soup-areas nil)
(defvar gnus-soup-last-prefix nil)
;;; Access macros:
(defmacro gnus-soup-area-prefix (area)
- (` (aref (, area) 0)))
+ `(aref ,area 0))
+(defmacro gnus-soup-set-area-prefix (area prefix)
+ `(aset ,area 0 ,prefix))
(defmacro gnus-soup-area-name (area)
- (` (aref (, area) 1)))
+ `(aref ,area 1))
(defmacro gnus-soup-area-encoding (area)
- (` (aref (, area) 2)))
+ `(aref ,area 2))
(defmacro gnus-soup-area-description (area)
- (` (aref (, area) 3)))
+ `(aref ,area 3))
(defmacro gnus-soup-area-number (area)
- (` (aref (, area) 4)))
+ `(aref ,area 4))
(defmacro gnus-soup-area-set-number (area value)
- (` (aset (, area) 4 (, value))))
+ `(aset ,area 4 ,value))
(defmacro gnus-soup-encoding-format (encoding)
- (` (aref (, encoding) 0)))
+ `(aref ,encoding 0))
(defmacro gnus-soup-encoding-index (encoding)
- (` (aref (, encoding) 1)))
+ `(aref ,encoding 1))
(defmacro gnus-soup-encoding-kind (encoding)
- (` (aref (, encoding) 2)))
+ `(aref ,encoding 2))
(defmacro gnus-soup-reply-prefix (reply)
- (` (aref (, reply) 0)))
+ `(aref ,reply 0))
(defmacro gnus-soup-reply-kind (reply)
- (` (aref (, reply) 1)))
+ `(aref ,reply 1))
(defmacro gnus-soup-reply-encoding (reply)
- (` (aref (, reply) 2)))
+ `(aref ,reply 2))
;;; Commands:
(let ((packets (directory-files
gnus-soup-packet-directory t gnus-soup-packet-regexp)))
(while packets
- (and (gnus-soup-send-packet (car packets))
- (delete-file (car packets)))
+ (when (gnus-soup-send-packet (car packets))
+ (delete-file (car packets)))
(setq packets (cdr packets)))))
(defun gnus-soup-add-article (n)
If N is nil and any articles have been marked with the process mark,
move those articles instead."
(interactive "P")
- (gnus-set-global-variables)
(let* ((articles (gnus-summary-work-articles n))
- (tmp-buf (get-buffer-create "*soup work*"))
+ (tmp-buf (gnus-get-buffer-create "*soup work*"))
(area (gnus-soup-area gnus-newsgroup-name))
(prefix (gnus-soup-area-prefix area))
headers)
(buffer-disable-undo tmp-buf)
(save-excursion
(while articles
- ;; Find the header of the article.
- (set-buffer gnus-summary-buffer)
- (setq headers (gnus-get-header-by-number (car articles)))
- ;; Put the article in a buffer.
+ ;; Put the article in a buffer.
(set-buffer tmp-buf)
- (gnus-request-article-this-buffer
- (car articles) gnus-newsgroup-name)
- (gnus-soup-store gnus-soup-directory prefix headers
- gnus-soup-encoding-type
- gnus-soup-index-type)
- (gnus-soup-area-set-number area
- (1+ (or (gnus-soup-area-number area) 0)))
- ;; Mark article as read.
+ (when (gnus-request-article-this-buffer
+ (car articles) gnus-newsgroup-name)
+ (setq headers (nnheader-parse-head t))
+ (save-restriction
+ (message-narrow-to-head)
+ (message-remove-header gnus-soup-ignored-headers t))
+ (gnus-soup-store gnus-soup-directory prefix headers
+ gnus-soup-encoding-type
+ gnus-soup-index-type)
+ (gnus-soup-area-set-number
+ area (1+ (or (gnus-soup-area-number area) 0))))
+ ;; Mark article as read.
(set-buffer gnus-summary-buffer)
(gnus-summary-remove-process-mark (car articles))
- (gnus-summary-mark-as-read (car articles) "F")
+ (gnus-summary-mark-as-read (car articles) gnus-souped-mark)
(setq articles (cdr articles)))
- (kill-buffer tmp-buf))))
+ (kill-buffer tmp-buf))
+ (gnus-soup-save-areas)
+ (gnus-set-mode-line 'summary)))
(defun gnus-soup-pack-packet ()
"Make a SOUP packet from the SOUP areas."
(interactive)
(gnus-soup-read-areas)
- (gnus-soup-pack gnus-soup-directory gnus-soup-packer))
+ (if (file-exists-p gnus-soup-directory)
+ (if (directory-files gnus-soup-directory nil "\\.MSG$")
+ (gnus-soup-pack gnus-soup-directory gnus-soup-packer)
+ (message "No files to pack."))
+ (message "No such directory: %s" gnus-soup-directory)))
(defun gnus-group-brew-soup (n)
"Make a soup packet from the current group.
(let ((groups (gnus-group-process-prefix n)))
(while groups
(gnus-group-remove-mark (car groups))
- (gnus-soup-group-brew (car groups))
+ (gnus-soup-group-brew (car groups) t)
(setq groups (cdr groups)))
(gnus-soup-save-areas)))
(let ((level (or level gnus-level-subscribed))
(newsrc (cdr gnus-newsrc-alist)))
(while newsrc
- (and (<= (nth 1 (car newsrc)) level)
- (gnus-soup-group-brew (car (car newsrc))))
+ (when (<= (nth 1 (car newsrc)) level)
+ (gnus-soup-group-brew (caar newsrc) t))
(setq newsrc (cdr newsrc)))
(gnus-soup-save-areas)))
For instance, if you want to brew on all the nnml groups, as well as
groups with \"emacs\" in the name, you could say something like:
-$ emacs -batch -f gnus-batch-brew-soup ^nnml \".*emacs.*\""
+$ emacs -batch -f gnus-batch-brew-soup ^nnml \".*emacs.*\"
+
+Note -- this function hasn't been implemented yet."
(interactive)
- )
-
+ nil)
+
;;; Internal Functions:
-;; Store the current buffer.
+;; Store the current buffer.
(defun gnus-soup-store (directory prefix headers format index)
- (add-hook 'gnus-exit-gnus-hook 'gnus-soup-save-areas)
- ;; Create the directory, if needed.
- (or (file-directory-p directory)
- (gnus-make-directory directory))
- (let* ((msg-buf (gnus-find-file-noselect
+ ;; Create the directory, if needed.
+ (gnus-make-directory directory)
+ (let* ((msg-buf (nnheader-find-file-noselect
(concat directory prefix ".MSG")))
(idx-buf (if (= index ?n)
nil
- (gnus-find-file-noselect
+ (nnheader-find-file-noselect
(concat directory prefix ".IDX"))))
(article-buf (current-buffer))
from head-line beg type)
- (setq gnus-soup-buffers (cons msg-buf gnus-soup-buffers))
+ (setq gnus-soup-buffers (cons msg-buf (delq msg-buf gnus-soup-buffers)))
(buffer-disable-undo msg-buf)
- (and idx-buf
- (progn
- (setq gnus-soup-buffers (cons idx-buf gnus-soup-buffers))
- (buffer-disable-undo idx-buf)))
+ (when idx-buf
+ (push idx-buf gnus-soup-buffers)
+ (buffer-disable-undo idx-buf))
(save-excursion
;; Make sure the last char in the buffer is a newline.
(goto-char (point-max))
- (or (= (current-column) 0)
- (insert "\n"))
+ (unless (= (current-column) 0)
+ (insert "\n"))
;; Find the "from".
(goto-char (point-min))
(setq from
- (mail-strip-quoted-names
+ (gnus-mail-strip-quoted-names
(or (mail-fetch-field "from")
(mail-fetch-field "really-from")
(mail-fetch-field "sender"))))
(goto-char (point-min))
;; Depending on what encoding is supposed to be used, we make
- ;; a soup header.
+ ;; a soup header.
(setq head-line
- (cond
+ (cond
((= gnus-soup-encoding-type ?n)
(format "#! rnews %d\n" (buffer-size)))
((= gnus-soup-encoding-type ?m)
(set-buffer idx-buf)
(gnus-soup-insert-idx beg headers))
((/= index ?n)
- (error "Unknown index type: %c" type))))))
+ (error "Unknown index type: %c" type)))
+ ;; Return the MSG buf.
+ msg-buf)))
-(defun gnus-soup-group-brew (group)
+(defun gnus-soup-group-brew (group &optional not-all)
+ "Enter GROUP and add all articles to a SOUP package.
+If NOT-ALL, don't pack ticked articles."
(let ((gnus-expert-user t)
- (gnus-large-newsgroup nil))
- (and (gnus-summary-read-group group)
- (let ((gnus-newsgroup-processable
- (gnus-sorted-complement
- gnus-newsgroup-unreads
- (append gnus-newsgroup-dormant gnus-newsgroup-marked))))
- (gnus-soup-add-article nil)))
- (gnus-summary-exit)))
+ (gnus-large-newsgroup nil)
+ (entry (gnus-gethash group gnus-newsrc-hashtb)))
+ (when (or (null entry)
+ (eq (car entry) t)
+ (and (car entry)
+ (> (car entry) 0))
+ (and (not not-all)
+ (gnus-range-length (cdr (assq 'tick (gnus-info-marks
+ (nth 2 entry)))))))
+ (when (gnus-summary-read-group group nil t)
+ (setq gnus-newsgroup-processable
+ (reverse
+ (if (not not-all)
+ (append gnus-newsgroup-marked gnus-newsgroup-unreads)
+ gnus-newsgroup-unreads)))
+ (gnus-soup-add-article nil)
+ (gnus-summary-exit)))))
(defun gnus-soup-insert-idx (offset header)
;; [number subject from date id references chars lines xref]
(goto-char (point-max))
(insert
- (format "%d\t%s\t%s\t%s\t%s\t%s\t%d\t%s\t%s\t\n"
+ (format "%d\t%s\t%s\t%s\t%s\t%s\t%d\t%s\t\t\n"
offset
- (or (header-subject header) "(none)")
- (or (header-from header) "(nobody)")
- (or (header-date header) "")
- (or (header-id header)
- (concat "soup-dummy-id-"
- (mapconcat
+ (or (mail-header-subject header) "(none)")
+ (or (mail-header-from header) "(nobody)")
+ (or (mail-header-date header) "")
+ (or (mail-header-id header)
+ (concat "soup-dummy-id-"
+ (mapconcat
(lambda (time) (int-to-string time))
(current-time) "-")))
- (or (header-references header) "")
- (or (header-chars header) 0)
- (or (header-lines header) "0")
- (or (header-xref header) ""))))
+ (or (mail-header-references header) "")
+ (or (mail-header-chars header) 0)
+ (or (mail-header-lines header) "0"))))
(defun gnus-soup-save-areas ()
+ "Write all SOUP buffers."
+ (interactive)
(gnus-soup-write-areas)
(save-excursion
(let (buf)
(if (not (buffer-name buf))
()
(set-buffer buf)
- (and (buffer-modified-p) (save-buffer))
+ (when (buffer-modified-p)
+ (save-buffer))
(kill-buffer (current-buffer)))))
- (let ((prefix gnus-soup-last-prefix))
- (while prefix
- (gnus-set-work-buffer)
- (insert (format "(setq gnus-soup-prev-prefix %d)\n"
- (cdr (car prefix))))
- (write-region (point-min) (point-max)
- (concat (car (car prefix))
- gnus-soup-prefix-file)
- nil 'nomesg)
- (setq prefix (cdr prefix))))))
+ (gnus-soup-write-prefixes)))
+
+(defun gnus-soup-write-prefixes ()
+ (let ((prefixes gnus-soup-last-prefix)
+ prefix)
+ (save-excursion
+ (gnus-set-work-buffer)
+ (while (setq prefix (pop prefixes))
+ (erase-buffer)
+ (insert (format "(setq gnus-soup-prev-prefix %d)\n" (cdr prefix)))
+ (gnus-write-buffer (concat (car prefix) gnus-soup-prefix-file))))))
(defun gnus-soup-pack (dir packer)
(let* ((files (mapconcat 'identity
(string-match "%d" packer))
(format packer files
(string-to-int (gnus-soup-unique-prefix dir)))
- (format packer
+ (format packer
(string-to-int (gnus-soup-unique-prefix dir))
files)))
(dir (expand-file-name dir)))
- (message "Packing %s..." packer)
- (if (zerop (call-process "sh" nil nil nil "-c"
+ (gnus-make-directory dir)
+ (setq gnus-soup-areas nil)
+ (gnus-message 4 "Packing %s..." packer)
+ (if (zerop (call-process shell-file-name
+ nil nil nil shell-command-switch
(concat "cd " dir " ; " packer)))
(progn
- (call-process "sh" nil nil nil "-c"
+ (call-process shell-file-name nil nil nil shell-command-switch
(concat "cd " dir " ; rm " files))
- (message "Packing...done" packer))
- (error "Couldn't pack packet."))))
+ (gnus-message 4 "Packing...done" packer))
+ (error "Couldn't pack packet"))))
(defun gnus-soup-parse-areas (file)
"Parse soup area file FILE.
The result is a of vectors, each containing one entry from the AREA file.
-The vector contain five strings,
+The vector contain five strings,
[prefix name encoding description number]
though the two last may be nil if they are missing."
(let (areas)
- (save-excursion
- (set-buffer (gnus-find-file-noselect file 'force))
- (buffer-disable-undo (current-buffer))
- (goto-char (point-min))
- (while (not (eobp))
- (setq areas
- (cons (vector (gnus-soup-field)
- (gnus-soup-field)
- (gnus-soup-field)
- (and (eq (preceding-char) ?\t)
- (gnus-soup-field))
- (and (eq (preceding-char) ?\t)
- (string-to-int (gnus-soup-field))))
- areas))
- (if (eq (preceding-char) ?\t)
- (beginning-of-line 2))))
+ (when (file-exists-p file)
+ (save-excursion
+ (set-buffer (nnheader-find-file-noselect file 'force))
+ (buffer-disable-undo)
+ (goto-char (point-min))
+ (while (not (eobp))
+ (push (vector (gnus-soup-field)
+ (gnus-soup-field)
+ (gnus-soup-field)
+ (and (eq (preceding-char) ?\t)
+ (gnus-soup-field))
+ (and (eq (preceding-char) ?\t)
+ (string-to-int (gnus-soup-field))))
+ areas)
+ (when (eq (preceding-char) ?\t)
+ (beginning-of-line 2)))
+ (kill-buffer (current-buffer))))
areas))
(defun gnus-soup-parse-replies (file)
"Parse soup REPLIES file FILE.
The result is a of vectors, each containing one entry from the REPLIES
-file. The vector contain three strings, [prefix name encoding]."
+file. The vector contain three strings, [prefix name encoding]."
(let (replies)
(save-excursion
- (set-buffer (gnus-find-file-noselect file))
- (buffer-disable-undo (current-buffer))
+ (set-buffer (nnheader-find-file-noselect file))
+ (buffer-disable-undo)
(goto-char (point-min))
(while (not (eobp))
- (setq replies
- (cons (vector (gnus-soup-field) (gnus-soup-field)
- (gnus-soup-field))
- replies))
- (if (eq (preceding-char) ?\t)
- (beginning-of-line 2))))
+ (push (vector (gnus-soup-field) (gnus-soup-field)
+ (gnus-soup-field))
+ replies)
+ (when (eq (preceding-char) ?\t)
+ (beginning-of-line 2)))
+ (kill-buffer (current-buffer)))
replies))
(defun gnus-soup-field ()
(gnus-soup-parse-areas (concat gnus-soup-directory "AREAS")))))
(defun gnus-soup-write-areas ()
- (if (not gnus-soup-areas)
- ()
- (save-excursion
- (set-buffer (gnus-find-file-noselect
- (concat gnus-soup-directory "AREAS")))
- (erase-buffer)
+ "Write the AREAS file."
+ (interactive)
+ (when gnus-soup-areas
+ (with-temp-file (concat gnus-soup-directory "AREAS")
(let ((areas gnus-soup-areas)
area)
- (while areas
- (setq area (car areas)
- areas (cdr areas))
- (insert (format "%s\t%s\t%s%s\n"
- (gnus-soup-area-prefix area)
- (gnus-soup-area-name area)
- (gnus-soup-area-encoding area)
- (if (or (gnus-soup-area-description area)
- (gnus-soup-area-number area))
- (concat "\t" (or (gnus-soup-area-description
- area)
- "")
- (if (gnus-soup-area-number area)
- (concat "\t"
- (int-to-string
- (gnus-soup-area-number
- area)))
- "")) "")))))
- (write-region (point-min) (point-max)
- (concat gnus-soup-directory "AREAS"))
- (set-buffer-modified-p nil)
- (kill-buffer (current-buffer)))))
+ (while (setq area (pop areas))
+ (insert
+ (format
+ "%s\t%s\t%s%s\n"
+ (gnus-soup-area-prefix area)
+ (gnus-soup-area-name area)
+ (gnus-soup-area-encoding area)
+ (if (or (gnus-soup-area-description area)
+ (gnus-soup-area-number area))
+ (concat "\t" (or (gnus-soup-area-description
+ area) "")
+ (if (gnus-soup-area-number area)
+ (concat "\t" (int-to-string
+ (gnus-soup-area-number area)))
+ "")) ""))))))))
(defun gnus-soup-write-replies (dir areas)
- (save-excursion
- (set-buffer (gnus-find-file-noselect (concat dir "REPLIES")))
- (erase-buffer)
+ "Write a REPLIES file in DIR containing AREAS."
+ (with-temp-file (concat dir "REPLIES")
(let (area)
- (while areas
- (setq area (car areas)
- areas (cdr areas))
+ (while (setq area (pop areas))
(insert (format "%s\t%s\t%s\n"
(gnus-soup-reply-prefix area)
- (gnus-soup-reply-kind area)
- (gnus-soup-reply-encoding area)))))
- (write-region (point-min) (point-max) (concat dir "REPLIES"))
- (set-buffer-modified-p nil)
- (kill-buffer (current-buffer))))
+ (gnus-soup-reply-kind area)
+ (gnus-soup-reply-encoding area)))))))
(defun gnus-soup-area (group)
(gnus-soup-read-areas)
(while areas
(setq area (car areas)
areas (cdr areas))
- (if (equal (gnus-soup-area-name area) real-group)
- (setq result area)))
- (or result
- (setq result
- (vector (gnus-soup-unique-prefix)
- real-group
- (format "%c%c%c"
- gnus-soup-encoding-type
- gnus-soup-index-type
- (if (gnus-member-of-valid 'mail group) ?m ?n))
- nil nil)
- gnus-soup-areas (cons result gnus-soup-areas)))
+ (when (equal (gnus-soup-area-name area) real-group)
+ (setq result area)))
+ (unless result
+ (setq result
+ (vector (gnus-soup-unique-prefix)
+ real-group
+ (format "%c%c%c"
+ gnus-soup-encoding-type
+ gnus-soup-index-type
+ (if (gnus-member-of-valid 'mail group) ?m ?n))
+ nil nil)
+ gnus-soup-areas (cons result gnus-soup-areas)))
result))
(defun gnus-soup-unique-prefix (&optional dir)
gnus-soup-prev-prefix)
(if entry
()
- (and (file-exists-p (concat dir gnus-soup-prefix-file))
- (condition-case nil
- (load-file (concat dir gnus-soup-prefix-file))
- (setq error nil)))
- (setq gnus-soup-last-prefix
- (cons (setq entry (cons dir (or gnus-soup-prev-prefix 0)))
- gnus-soup-last-prefix)))
+ (when (file-exists-p (concat dir gnus-soup-prefix-file))
+ (ignore-errors
+ (load (concat dir gnus-soup-prefix-file) nil t t)))
+ (push (setq entry (cons dir (or gnus-soup-prev-prefix 0)))
+ gnus-soup-last-prefix))
(setcdr entry (1+ (cdr entry)))
+ (gnus-soup-write-prefixes)
(int-to-string (cdr entry))))
(defun gnus-soup-unpack-packet (dir unpacker packet)
+ "Unpack PACKET into DIR using UNPACKER.
+Return whether the unpacking was successful."
(gnus-make-directory dir)
- (message "Unpacking: %s" (format unpacker packet))
- (call-process
- "sh" nil nil nil "-c"
- (format "cd %s ; %s" (expand-file-name dir) (format unpacker packet)))
- (message "Unpacking...done"))
+ (gnus-message 4 "Unpacking: %s" (format unpacker packet))
+ (prog1
+ (zerop (call-process
+ shell-file-name nil nil nil shell-command-switch
+ (format "cd %s ; %s" (expand-file-name dir)
+ (format unpacker packet))))
+ (gnus-message 4 "Unpacking...done")))
(defun gnus-soup-send-packet (packet)
- (gnus-soup-unpack-packet
+ (gnus-soup-unpack-packet
gnus-soup-replies-directory gnus-soup-unpacker packet)
- (let ((replies (gnus-soup-parse-replies
+ (let ((replies (gnus-soup-parse-replies
(concat gnus-soup-replies-directory "REPLIES"))))
(save-excursion
(while replies
(gnus-soup-reply-prefix (car replies))
".MSG"))
(msg-buf (and (file-exists-p msg-file)
- (gnus-find-file-noselect msg-file)))
- (tmp-buf (get-buffer-create " *soup send*"))
+ (nnheader-find-file-noselect msg-file)))
+ (tmp-buf (gnus-get-buffer-create " *soup send*"))
beg end)
- (cond
- ((/= (gnus-soup-encoding-format
- (gnus-soup-reply-encoding (car replies))) ?n)
+ (cond
+ ((/= (gnus-soup-encoding-format
+ (gnus-soup-reply-encoding (car replies)))
+ ?n)
(error "Unsupported encoding"))
((null msg-buf)
t)
(t
(buffer-disable-undo msg-buf)
- (buffer-disable-undo tmp-buf)
(set-buffer msg-buf)
(goto-char (point-min))
(while (not (eobp))
- (or (looking-at "#! *rnews +\\([0-9]+\\)")
- (error "Bad header."))
+ (unless (looking-at "#! *rnews +\\([0-9]+\\)")
+ (error "Bad header"))
(forward-line 1)
(setq beg (point)
- end (+ (point) (string-to-int
- (buffer-substring
+ end (+ (point) (string-to-int
+ (buffer-substring
(match-beginning 1) (match-end 1)))))
(switch-to-buffer tmp-buf)
(erase-buffer)
(search-forward "\n\n")
(forward-char -1)
(insert mail-header-separator)
- (cond
+ (setq message-newsreader (setq message-mailer
+ (gnus-extended-version)))
+ (cond
((string= (gnus-soup-reply-kind (car replies)) "news")
- (message "Sending news message to %s..."
- (mail-fetch-field "newsgroups"))
+ (gnus-message 5 "Sending news message to %s..."
+ (mail-fetch-field "newsgroups"))
(sit-for 1)
- (gnus-inews-article))
+ (let ((message-syntax-checks
+ 'dont-check-for-anything-just-trust-me))
+ (funcall message-send-news-function)))
((string= (gnus-soup-reply-kind (car replies)) "mail")
- (message "Sending mail to %s..."
- (mail-fetch-field "to"))
+ (gnus-message 5 "Sending mail to %s..."
+ (mail-fetch-field "to"))
(sit-for 1)
- (gnus-mail-send-and-exit))
+ (message-send-mail))
(t
(error "Unknown reply kind")))
(set-buffer msg-buf)
(delete-file (buffer-file-name))
(kill-buffer msg-buf)
(kill-buffer tmp-buf)
- (message "Sent packet"))))
+ (gnus-message 4 "Sent packet"))))
(setq replies (cdr replies)))
t)))
-
+
(provide 'gnus-soup)
;;; gnus-soup.el ends here
projects / gnus / blobdiff