Merge pull request #96 from countvajhula/more-gardening

More gardening

Author: countvajhula

symex-primitives-lisp.el

@@ -46,6 +46,19 @@
               (looking-back "[,'`]" (line-beginning-position))
               (save-excursion (backward-char)  ; just inside symex
                               (or (symex-left-p)
+                                  ;; this is to exclude the case where
+                                  ;; we're inside a string, "|abc"
+                                  ;; which "inverts" the code structure
+                                  ;; and causes unexpected behavior when
+                                  ;; navigating using Emacs's built-in
+                                  ;; primitive symex motions. Unlike normal
+                                  ;; forms, opening and closing delimiters
+                                  ;; are not distinguished for strings and
+                                  ;; so we can't specifically check for
+                                  ;; "open quote," with the result that
+                                  ;; in the case "abc"|, we don't always
+                                  ;; select the right symex the way we
+                                  ;; would with (abc)|.
                                   (symex-string-p))))
     (condition-case nil
         (backward-sexp)
@@ -344,7 +357,6 @@ as special cases here."
   "Select the appropriate symex nearest to point."
   (cond ((and (not (eobp))
               (save-excursion (forward-char) (symex-right-p))) ; |)
-         (forward-char)
          (symex-other))
         ((thing-at-point 'sexp)       ; som|ething
          (beginning-of-thing 'sexp))

symex-transformations-lisp.el

@@ -89,7 +89,7 @@
   (cond ((symex--current-line-empty-p)         ; ^<>$
          ;; only join up to the next symex if the context suggests
          ;; that a line break is not desired
-         (if (or (save-excursion (next-line)
+         (if (or (save-excursion (forward-line)
                                  (not (symex--current-line-empty-p)))
                  (save-excursion (previous-line)
                                  (symex--current-line-empty-p)))
@@ -99,7 +99,13 @@
         ((or (save-excursion (evil-last-non-blank) ; (<>$
                              (symex-left-p)))
          (symex--join-to-next))
-        ((looking-at-p "\n") (symex--go-backward)) ; (abc <>
+        ((looking-at-p "\n")  ; (abc <>
+         (if (save-excursion (forward-line)
+                             (not (symex--current-line-empty-p)))
+             ;; only join up to the next symex if the context suggests
+             ;; that a line break is not desired
+             (symex--join-to-next)
+           (symex--go-backward)))
         ((save-excursion (back-to-indentation) ; ^<>)
                          (forward-char)
                          (symex-right-p))
@@ -109,18 +115,18 @@
          ;; on the same line, then don't attempt to join lines
          (let ((original-position (point)))
            (when (symex--go-backward)
-             (let ((previous-symex-end-pos (symex--get-end-point 1)))
-               (unless (symex--intervening-comment-line-p previous-symex-end-pos
-                                                          original-position)
-                 (goto-char previous-symex-end-pos)
-                 ;; ensure that there isn't a comment on the
-                 ;; preceding line before joining lines
-                 (unless (condition-case nil
-                             (progn (evil-find-char 1 ?\;)
-                                    t)
-                           (error nil))
-                   (symex--join-to-match symex--re-right)
-                   (symex--adjust-point)))))))
+             (save-excursion
+               (let ((previous-symex-end-pos (symex--get-end-point 1)))
+                 (unless (symex--intervening-comment-line-p previous-symex-end-pos
+                                                            original-position)
+                   (goto-char previous-symex-end-pos)
+                   ;; ensure that there isn't a comment on the
+                   ;; preceding line before joining lines
+                   (unless (condition-case nil
+                               (progn (evil-find-char 1 ?\;)
+                                      t)
+                             (error nil))
+                     (symex--join-to-match symex--re-right))))))))
         ((save-excursion (forward-char) ; ... <>)
                          (symex-right-p))
          (symex--go-backward))
@@ -209,17 +215,28 @@ text, on the respective side."
                               (eolp))
               ;; and if the side we want to paste on already
               ;; contains an empty line,
-              (save-excursion (if before
+              (save-excursion (if (or before
+                                      ;; if we happen to be at the end
+                                      ;; of the buffer for pasting after,
+                                      ;; then check the opposite side instead
+                                      ;; for the clue on what's expected
+                                      (save-excursion (forward-sexp)
+                                                      (eobp)))
                                   (previous-line)
-                                (progn (forward-sexp) (next-line)))
+                                (progn (forward-sexp)
+                                       (forward-line)))
                               (symex--current-line-empty-p))
               ;; and if the text to be pasted contains newlines,
               ;; then we typically want an extra newline separator
               (seq-contains-p (current-kill 0 t) ?\n))
          "\n\n")
         ((or (symex--point-at-indentation-p)
-             (save-excursion (forward-sexp)
-                             (eolp)))
+             (let ((original-line (line-number-at-pos)))
+               (save-excursion (forward-sexp)
+                               (or (eolp)
+                                   ;; for multi-line symex, add a newline
+                                   (not (= original-line
+                                           (line-number-at-pos)))))))
          "\n")
         (t " ")))
 

symex-transformations.el

@@ -166,14 +166,15 @@
 
 (defun symex--capture-backward ()
   "Capture from behind."
-  (when (symex-left-p)
+  (when (and (symex-left-p)
+             ;; paredit captures 1 ((|2 3)) -> (1 (2 3)) but we don't
+             ;; want to in this case since point indicates the inner
+             ;; symex, which cannot capture, rather than the outer
+             ;; one. We avoid this by employing a guard condition here.
+             (not (symex--point-at-first-symex-p)))
     (if (symex-empty-list-p)
         (forward-char)
       (symex--go-up))  ; need to be inside the symex to emit and capture
-    ;; paredit captures 1 ((|2 3)) -> (1 (2 3))
-    ;; but we don't want to in this case since point indicates the
-    ;; inner symex, which cannot capture, rather than the outer
-    ;; one. Just a note for the future.
     (paredit-backward-slurp-sexp 1)
     (fixup-whitespace)
     (symex--go-down)))
@@ -331,8 +332,9 @@ by default, joins next symex to current one."
                 (concat (symex-lisp-paste-after)
                         pasted-text)))
         (save-excursion
+          (forward-sexp) ; go to beginning of pasted text
           (goto-char (+ (point)
-                        (length pasted-text)))
+                        (length pasted-text))) ; end of pasted text
           (symex--same-line-tidy-affected))
         ;; move to indicate appropriate posterior selection
         (forward-sexp)
@@ -816,7 +818,7 @@ implementation."
 (symex-define-command symex-tidy-remaining ()
   "Tidy the remaining symexes."
   (interactive)
-  (save-excursion
+  (symex--save-point-excursion
     ;; do it once first since it will be executed as a side-effect
     ;; _after_ each step in the traversal
     (symex--tidy 1)