emacs: lisp/gnus/nnmail.el comparison

comparison lisp/gnus/nnmail.el @ 85712:a3c27999decb

Update Gnus to No Gnus 0.7 from the Gnus CVS trunk Revision: emacs@sv.gnu.org/emacs--devo--0--patch-911

author	Miles Bader <miles@gnu.org>
date	Sun, 28 Oct 2007 09:18:39 +0000
parents	7bb8a742f977
children	166a6141ae98 880960b70474

comparison

equal deleted inserted replaced

-:b6f5dc84b2e1
+:a3c27999decb
 (eval-when-compile (require 'cl))
 (require 'gnus)				; for macro gnus-kill-buffer, at least
 (require 'nnheader)
 (require 'message)
-(require 'custom)
 (require 'gnus-util)
 (require 'mail-source)
 (require 'mm-util)
 (eval-and-compile
 Eg.
 \(add-hook 'nnmail-read-incoming-hook
 	  (lambda ()
 	    (call-process \"/local/bin/mailsend\" nil nil nil
-			  \"read\" nnmail-spool-file)))
+			  \"read\"
+			  ;; The incoming mail box file.
+			  (expand-file-name (user-login-name)
+					    rmail-spool-directory))))
 If you have xwatch running, this will alert it that mail has been
 read.
 If you use `display-time', you could use something like this:
 (editable-list :inline t nnmail-split-fancy))
 (list :tag "Use all matches (&)" :value (&)
 (const :format "" &)
 (editable-list :inline t nnmail-split-fancy))
 (list :tag "Function with fixed arguments (:)"
-:value (: nil)
+:value (:)
 (const :format "" :value :)
 function
 (editable-list :inline t (sexp :tag "Arg"))
 )
 (list :tag "Function with split arguments (!)"
-:value (! nil)
+:value (!)
 (const :format "" !)
 function
 (editable-list :inline t nnmail-split-fancy))
 (list :tag "Field match"
 (choice :tag "Field"
 FIELD must match a complete field name.  VALUE must match a complete
 word according to the `nnmail-split-fancy-syntax-table' syntax table.
 You can use \".*\" in the regexps to match partial field names or words.
-FIELD and VALUE can also be lisp symbols, in that case they are expanded
+FIELD and VALUE can also be Lisp symbols, in that case they are expanded
 as specified in `nnmail-split-abbrev-alist'.
 GROUP can contain \\& and \\N which will substitute from matching
 \\(\\) patterns in the previous VALUE.
 (if (or nnmail-use-long-file-names
 	      (file-directory-p (concat dir group)))
 	  (expand-file-name group dir)
 	;; If not, we translate dots into slashes.
 	(expand-file-name
-	 (mm-encode-coding-string
+	 (nnheader-replace-chars-in-string group ?. ?/)
-	  (nnheader-replace-chars-in-string group ?. ?/)
-	  nnmail-pathname-coding-system)
 	 dir))))
 (or file "")))
 (defun nnmail-get-active ()
 "Returns an assoc of group names and active ranges.
 (let ((buffer (current-buffer))
 	group-assoc group max min)
 (while (not (eobp))
 (condition-case err
 	  (progn
-	    (narrow-to-region (point) (gnus-point-at-eol))
+	    (narrow-to-region (point) (point-at-eol))
 	    (setq group (read buffer))
 	    (unless (stringp group)
 	      (setq group (symbol-name group)))
 	    (if (and (numberp (setq max (read buffer)))
 		     (numberp (setq min (read buffer))))
 (save-excursion
 (goto-char (point-min))
 (nnmail-check-duplication message-id func artnum-func))
 1))
+(defvar nnmail-group-names-not-encoded-p nil
+"Non-nil means group names are not encoded.")
 (defun nnmail-split-incoming (incoming func &optional exit-func
 				       group artnum-func)
 "Go through the entire INCOMING file and pick out each individual mail.
 FUNC will be called with the buffer narrowed to each mail."
 (let ( ;; If this is a group-specific split, we bind the split
 	;; methods to just this group.
 	(nnmail-split-methods (if (and group
 				       (not nnmail-resplit-incoming))
 				  (list (list group ""))
-				nnmail-split-methods)))
+				nnmail-split-methods))
+	(nnmail-group-names-not-encoded-p t))
 (save-excursion
 ;; Insert the incoming file.
 (set-buffer (get-buffer-create nnmail-article-buffer))
 (erase-buffer)
 (let ((coding-system-for-read nnmail-incoming-coding-system))
 	;; existence to process.
 	(goto-char (point-min))
 	(while (not (eobp))
 	  (unless (< (move-to-column nnmail-split-header-length-limit)
 		     nnmail-split-header-length-limit)
-	    (delete-region (point) (gnus-point-at-eol)))
+	    (delete-region (point) (point-at-eol)))
 	  (forward-line 1))
 	;; Allow washing.
 	(goto-char (point-min))
 	(run-hooks 'nnmail-split-hook)
 	(when (setq nnmail-split-tracing trace)
 (when (re-search-backward "^Xref: " nil t)
 (delete-region (match-beginning 0)
 		     (progn (forward-line 1) (point))))
 (insert (format "Xref: %s" (system-name)))
 (while group-alist
-(insert (format " %s:%d"
+(insert (if (mm-multibyte-p)
-		      (mm-encode-coding-string
+		  (mm-string-as-multibyte
-		       (caar group-alist)
+		   (format " %s:%d" (caar group-alist) (cdar group-alist)))
-		       nnmail-pathname-coding-system)
+		(mm-string-as-unibyte
-		      (cdar group-alist)))
+		 (format " %s:%d" (caar group-alist) (cdar group-alist)))))
 (setq group-alist (cdr group-alist)))
 (insert "\n")))
 ;;; Message washing functions
 (defun nnmail-remove-tabs ()
 "Translate TAB characters into SPACE characters."
 (subst-char-in-region (point-min) (point-max) ?\t ?  t))
-(defun nnmail-fix-eudora-headers ()
+(defcustom nnmail-broken-references-mailers
-"Eudora has a broken References line, but an OK In-Reply-To."
+"^X-Mailer:.*\\(Eudora\\|Pegasus\\)"
+"Header line matching mailer producing bogus References lines.
+See `nnmail-ignore-broken-references'."
+:group 'nnmail-prepare
+:version "23.0" ;; No Gnus
+:type 'regexp)
+(defun nnmail-ignore-broken-references ()
+"Ignore the References line and use In-Reply-To
+Eudora has a broken References line, but an OK In-Reply-To."
 (goto-char (point-min))
-(when (re-search-forward "^X-Mailer:.*Eudora" nil t)
+(when (re-search-forward nnmail-broken-references-mailers nil t)
 (goto-char (point-min))
 (when (re-search-forward "^References:" nil t)
 (beginning-of-line)
 (insert "X-Gnus-Broken-Eudora-"))
 (goto-char (point-min))
 (when (re-search-forward "^\\(In-Reply-To:[^\n]+\\)\n[ \t]+" nil t)
 (replace-match "\\1" t))))
+(defalias 'nnmail-fix-eudora-headers 'nnmail-ignore-broken-references)
+(make-obsolete 'nnmail-fix-eudora-headers 'nnmail-ignore-broken-references)
 (custom-add-option 'nnmail-prepare-incoming-header-hook
-		   'nnmail-fix-eudora-headers)
+		   'nnmail-ignore-broken-references)
 ;;; Utility functions
 (defun nnmail-do-request-post (accept-func &optional server)
 "Utility function to directly post a message to an nnmail-derived group.
 	  (setq success nil))))))
 (defun nnmail-split-fancy ()
 "Fancy splitting method.
 See the documentation for the variable `nnmail-split-fancy' for details."
-(let ((syntab (syntax-table)))
+(with-syntax-table nnmail-split-fancy-syntax-table
-(unwind-protect
+(nnmail-split-it nnmail-split-fancy)))
-	(progn
-	  (set-syntax-table nnmail-split-fancy-syntax-table)
-	  (nnmail-split-it nnmail-split-fancy))
-(set-syntax-table syntab))))
 (defvar nnmail-split-cache nil)
 ;; Alist of split expressions their equivalent regexps.
 (defun nnmail-split-it (split)
 (when (search-backward id nil t)
 	(beginning-of-line)
 	(skip-chars-forward "^\n\r\t")
 	(unless (looking-at "[\r\n]")
 	  (forward-char 1)
-	  (buffer-substring (point) (gnus-point-at-eol)))))))
+	  (buffer-substring (point) (point-at-eol)))))))
 ;; Function for nnmail-split-fancy: look up all references in the
 ;; cache and if a match is found, return that group.
 (defun nnmail-split-fancy-with-parent ()
 "Split this message into the same group as its parent.
 		   nnmail-split-fancy-with-parent-ignore-groups)))
 (when refstr
 (setq references (nreverse (gnus-split-references refstr)))
 (unless (gnus-buffer-live-p nnmail-cache-buffer)
 	(nnmail-cache-open))
-(mapcar (lambda (x)
+(dolist (x references)
-		(setq res (or (nnmail-cache-fetch-group x) res))
+	(setq res (or (nnmail-cache-fetch-group x) res))
-		(when (or (member res '("delayed" "drafts" "queue"))
+	(when (or (member res '("delayed" "drafts" "queue"))
-			  (and regexp res (string-match regexp res)))
+		  (and regexp res (string-match regexp res)))
-		  (setq res nil)))
+	  (setq res nil)))
-	      references)
 res)))
 (defun nnmail-cache-id-exists-p (id)
 (when nnmail-treat-duplicates
 (save-excursion
 ;; To or From header
 ((and (equal header 'to-from)
 	     (or (string-match (cadr regexp-target-pair) from)
 		 (and (string-match (cadr regexp-target-pair) to)
 		      (let ((rmail-dont-reply-to-names
-			     message-dont-reply-to-names))
+			     (message-dont-reply-to-names)))
 			(equal (rmail-dont-reply-to from) "")))))
 	(setq target (format-time-string (caddr regexp-target-pair) date)))
 ((and (not (equal header 'to-from))
 	     (string-match (cadr regexp-target-pair)
 			   (or
 (unless nnmail-split-history
 (error "No current split history"))
 (with-output-to-temp-buffer "*nnmail split history*"
 (with-current-buffer standard-output
 (fundamental-mode))		; for Emacs 20.4+
-(let ((history nnmail-split-history)
+(dolist (elem nnmail-split-history)
-	  elem)
-(while (setq elem (pop history))
 	(princ (mapconcat (lambda (ga)
 			    (concat (car ga) ":" (int-to-string (cdr ga))))
 			  elem
 			  ", "))
-	(princ "\n")))))
+	(princ "\n"))))
 (defun nnmail-purge-split-history (group)
 "Remove all instances of GROUP from `nnmail-split-history'."
 (let ((history nnmail-split-history))
 (while history

Mercurial > emacs

comparison lisp/gnus/nnmail.el @ 85712:a3c27999decb