Tweak `paredit-convolute-sexp' a little and add some tests for it.

Ignore-this: 61dbcae678e46499873949c68cc78fbf

Thanks to Leo Liu for the nudge about some of its rough corners (and
for pointing out the screw case recently fixed).  It's still pretty
rough around the edges.

darcs-hash:20110508175637-00fcc-265b11688b79f4d01211d798fec7e9dd3fe4748f

2 files changed, 22 insertions, 6 deletions

diff --git a/paredit.el b/paredit.el
index c8b82ca..d137743 100644
--- a/paredit.el
+++ b/paredit.el
@@ -423,7 +423,7 @@ Paredit behaves badly if parentheses are unbalanced, so exercise
                  "|body"))
    ("M-?"       paredit-convolute-sexp
                 ("(let ((x 5) (y 3)) (frob |(zwonk)) (wibblethwop))"
-                 "|(frob (let ((x 5) (y 3)) (zwonk) (wibblethwop)))"))
+                 "(frob |(let ((x 5) (y 3)) (zwonk) (wibblethwop)))"))
 
    "Barfage & Slurpage"
    (("C-)" "C-<right>")
@@ -2124,6 +2124,9 @@ If the point is on an S-expression, such as a string or a symbol, not
       (let* ((indent-start (point))
              (indent-end (save-excursion (insert sexps) (point))))
         (indent-region indent-start indent-end nil)))))
+
+;;; The effects of convolution on the surrounding whitespace are pretty
+;;; random.  If you have better suggestions, please let me know.
 
 (defun paredit-convolute-sexp (&optional n)
   "Convolute S-expressions.
@@ -2134,7 +2137,7 @@ With a prefix argument N, move up N lists before wrapping."
   (interactive "p")
   (paredit-lose-if-not-in-sexp 'paredit-convolute-sexp)
   ;; Make sure we can move up before destroying anything.
-  (save-excursion (backward-up-list) (backward-up-list))
+  (save-excursion (backward-up-list n) (backward-up-list))
   (let (open close)                     ;++ Is this a good idea?
     (let ((prefix
            (let ((end (point)))
@@ -2146,12 +2149,17 @@ With a prefix argument N, move up N lists before wrapping."
                                (setq close (char-before))
                                (backward-delete-char 1))
                (setq open (char-after))
-               (delete-region (point) end)))))
+               (delete-region (point) end)
+               ;; I'm not sure this makes sense...
+               (if (not (eolp)) (just-one-space))))))
       (backward-up-list n)
       (paredit-insert-pair 1 open close 'goto-char)
       (insert prefix)
-      (backward-up-list)
-      (paredit-ignore-sexp-errors (indent-sexp)))))
+      ;; I'm not sure this makes sense either...
+      (if (not (eolp)) (just-one-space))
+      (save-excursion
+        (backward-up-list)
+        (paredit-ignore-sexp-errors (indent-sexp))))))
 
 (defun paredit-splice-string (argument)
   (let ((original-point (point))
diff --git a/test.el b/test.el
index 4d83010..3bb389a 100644
--- a/test.el
+++ b/test.el
@@ -359,4 +359,12 @@ Four arguments: the paredit command, the text of the buffer
     ("(paredit-canary|  ;\n)\n(lose)")))
 
 (paredit-test 'paredit-convolute-sexp
-  '(("(let ((x 5) (y 3)) |(frob (zwonk)) (wibblethwop))" error)))
+  '(("(let ((x 5) (y 3)) |(frob (zwonk)) (wibblethwop))" error)
+    ("(let ((x 0)) (progn| x))" "(progn |(let ((x 0)) x))")
+    ;; Should the space be left inside the LET?  In both cases?
+    ("(let ((x 0)) (progn| ))" "(progn |(let ((x 0)) ))")
+    ("(let ((x 0)) (progn|))" "(progn |(let ((x 0)) ))")
+    ;; One space should definitely be left between A and B here.
+    ("(let ((x 0)) a (progn|) b)" "(progn |(let ((x 0)) a b))")
+    ("(let ((x 0)) a (progn| ) b)" "(progn |(let ((x 0)) a b))")
+    ("(let ((x 0)) a (progn |) b)" "(progn |(let ((x 0)) a b))")))