Retooling fill-paragraph to append trailing spaces

Question

I'm using emacs as an external editor for mutt, and am hoping to get format=flowed messages to compose properly. The default behavior for fill-paragraph is to end lines without any whitespace, but the format=flowed style as detailed in RFC 2646 and 3676 requires trailing spaces before "soft" newlines. Is there an easy modification to append a space before every newline added by fill-paragraph? My elisp skill is quite limited.

To elaborate on specifically what kind of text is wanted, RFC 3676 establishes the "format=flowed" parameter to MIME type text/plain to describe text that flows well both on devices that automatically line-wrap and those that don't. The salient idea is that a newline immediately following a space is considered a "soft" newline, one provided for line-wrapping for display on devices which don't automatically line-wrap, and that other devices are free to remove this newline and to wrap text according to their own preferences. A newline without a preceding space is a "hard" newline, one meant to be rendered as a newline regardless of the line-width or wrap capabilities of the display.

So from a text processing point of view, what I'd like for format=flowed text is for fill-paragraph to precede every intra-paragraph line break with at least one whitespace, while leaving the end-of-paragraph line break with no whitespace preceding it. All of this of course could be done with post-processing search-and-replace on all my messages, but it seems like it should be possible to dothis with some appropriate modification of fill-paragraph.

Answer 1

I've kludged together a solution; posting it here for the edification of anyone who might find it handy. It's a complete redefinition of fill-newline which adds a space at the end, and it almost certainly breaks some other things, but since I use it in a very limited context, it doesn't seem to end up causing trouble. Duplicate at your own risk, of course. I added the following to my .emacs:

(defun my-message-configuration ()
  "Redefines fill-newline to beahve 3676ishly, and turns off auto fill"
  (turn-off-auto-fill)
(defun fill-newline ()
  ;; Replace whitespace here with one newline, then
  ;; indent to left margin.
  (skip-chars-backward " \t")
  (insert ?\s)
  (insert ?\n)
  ;; Give newline the properties of the space(s) it replaces
  (set-text-properties (1- (point)) (point)
               (fill-text-properties-at (point)))
  (and (looking-at "\\( [ \t]*\\)\\(\\c|\\)?")
       (or (aref (char-category-set (or (char-before (1- (point))) ?\000)) ?|)
       (match-end 2))
       ;; When refilling later on, this newline would normally not be replaced
       ;; by a space, so we need to mark it specially to re-install the space
       ;; when we unfill.
       (put-text-property (1- (point)) (point) 'fill-space (match-string 1)))
  ;; If we don't want breaks in invisible text, don't insert
  ;; an invisible newline.
  (if fill-nobreak-invisible
      (remove-text-properties (1- (point)) (point)
                  '(invisible t)))
  (if (or fill-prefix
      (not fill-indent-according-to-mode))
      (fill-indent-to-left-margin)
    (indent-according-to-mode))
  ;; Insert the fill prefix after indentation.
  (and fill-prefix (not (equal fill-prefix ""))
       ;; Markers that were after the whitespace are now at point: insert
       ;; before them so they don't get stuck before the prefix.
       (insert-before-markers-and-inherit fill-prefix)))
)

(add-hook 'message-mode-hook 'my-message-configuration)

The only real change this makes to fill-newline is the (insert ?\s) before the newline insert. As I said, an ugly hack which might well break any other code which expects fill-newline to behave conventionally, and I'd welcome a less dirty way to achieve the same result, but for now this works.