Rename -out-forward to -right, and -out-backward to -left

* lispy.el (lispy-out-forward): declare obsolete in 0.21.0.
(lispy-out-backward): declare obsolete in 0.21.0.
(lispy-out-forward-nostring): declare obsolete in 0.21.0.

Author: abo-abo

lispy-pkg.el

@@ -1,4 +1,4 @@
-(define-package "lispy" "0.17.0"
+(define-package "lispy" "0.21.0"
   "vi-like Paredit"
   '((helm "1.5.3")
     (ace-jump-mode "2.0")

lispy-test.el

@@ -190,26 +190,26 @@ Insert KEY if there's no command."
   (should (string= (lispy-with "(foo)\n;; (foo bar\n;;      tanf)|" "[")
                    "|(foo)\n;; (foo bar\n;;      tanf)")))
 
-(ert-deftest lispy-out-forward ()
+(ert-deftest lispy-right ()
   (should (string= (lispy-with "(|(a) (b) (c))" "l")
                    "((a) (b) (c))|"))
   (should (string= (lispy-with "(|(a) (b) (c))" "ll")
                    "((a) (b) (c))|"))
-  (should (string= (lispy-with "(|(a) (b) (c))" (lispy-out-forward 1))
+  (should (string= (lispy-with "(|(a) (b) (c))" (lispy-right 1))
                    "((a) (b) (c))|"))
   (should (string= (lispy-with "(|(a) (b) (c))"
-                               (lispy-out-forward 1)
-                               (lispy-out-forward 1))
+                               (lispy-right 1)
+                               (lispy-right 1))
                    "((a) (b) (c))|"))
-  (should (string= (lispy-with "((|a) (b) (c))" (lispy-out-forward 1))
+  (should (string= (lispy-with "((|a) (b) (c))" (lispy-right 1))
                    "((a)| (b) (c))"))
   (should (string= (lispy-with "((|a) (b) (c))"
-                               (lispy-out-forward 1)
-                               (lispy-out-forward 1))
+                               (lispy-right 1)
+                               (lispy-right 1))
                    "((a) (b) (c))|"))
-  (should (string= (lispy-with "((|a) (b) (c))" (lispy-out-forward 2))
+  (should (string= (lispy-with "((|a) (b) (c))" (lispy-right 2))
                    "((a) (b) (c))|"))
-  (should (string= (lispy-with "((a) \"(|foo)\" (c))" (lispy-out-forward 2))
+  (should (string= (lispy-with "((a) \"(|foo)\" (c))" (lispy-right 2))
                    "((a) \"(foo)\" (c))|"))
   (should (string= (lispy-with "(defun foo ()\n  (let ((a 1))\n    (let ((b 2))\n      (something)|)))" "l")
                    "(defun foo ()\n  (let ((a 1))\n    (let ((b 2))\n      (something))|))"))
@@ -228,7 +228,7 @@ Insert KEY if there's no command."
   (should (string= (lispy-with "(defun foo ()\n  (let ((a 1))\n    (let ((b 2))\n      |(something))))" "9l")
                    "(defun foo ()\n  (let ((a 1))\n    (let ((b 2))\n      (something))))|")))
 
-(ert-deftest lispy-out-backward ()
+(ert-deftest lispy-left ()
   (should (string= (lispy-with "(|(a) (b) (c))" "h")
                    "|((a) (b) (c))"))
   (should (string= (lispy-with "(|(a) (b) (c))" "hh")

lispy.el

@@ -4,7 +4,7 @@
 
 ;; Author: Oleh Krehel <[email protected]>
 ;; URL: https://github.com/abo-abo/lispy
-;; Version: 0.20.0
+;; Version: 0.21.0
 ;; Keywords: lisp
 
 ;; This file is not part of GNU Emacs
@@ -58,8 +58,8 @@
 ;; To move the point into a special position, use:
 ;; "]" - calls `lispy-forward'
 ;; "[" - calls `lispy-backward'
-;; "C-3" - calls `lispy-out-forward' (exit current list forwards)
-;; ")" - calls `lispy-out-forward-nostring' (exit current list
+;; "C-3" - calls `lispy-right' (exit current list forwards)
+;; ")" - calls `lispy-right-nostring' (exit current list
 ;;       forwards, but self-insert in strings and comments)
 ;;
 ;; These are the few Lispy commands that don't care whether the point
@@ -414,7 +414,7 @@ Use the command `%s' to change this variable."
 (defun lispy-forward (arg)
   "Move forward list ARG times or until error.
 Return t if moved at least once,
-otherwise call `lispy-out-forward' and return nil."
+otherwise call `lispy-right' and return nil."
   (interactive "p")
   (when (= arg 0)
     (setq arg 2000))
@@ -467,7 +467,7 @@ If couldn't move backward at least once, move up backward and return nil."
           (backward-list))
       (point))))
 
-(defun lispy-out-forward (arg)
+(defun lispy-right (arg)
   "Move outside list forwards ARG times.
 Return nil on failure, t otherwise."
   (interactive "p")
@@ -483,7 +483,14 @@ Return nil on failure, t otherwise."
         (t
          (lispy--out-forward arg))))
 
-(defun lispy-out-forward-nostring (arg)
+(define-obsolete-function-alias 'lispy-out-forward
+    'lispy-right "0.21.0")
+(define-obsolete-function-alias 'lispy-out-backward
+    'lispy-left "0.21.0")
+(define-obsolete-function-alias 'lispy-out-forward-nostring
+    'lispy-right-nostring "0.21.0")
+
+(defun lispy-right-nostring (arg)
   "Call `lispy--out-forward' with ARG unless in string or comment.
 Self-insert otherwise."
   (interactive "p")
@@ -493,9 +500,9 @@ Self-insert otherwise."
     (lispy--out-forward arg)))
 
 (defvar lispy-pre-outline-pos 1
-  "Point position before moving to outline with `lispy-out-backward'.")
+  "Point position before moving to outline with `lispy-left'.")
 
-(defun lispy-out-backward (arg)
+(defun lispy-left (arg)
   "Move outside list forwards ARG times.
 Return nil on failure, t otherwise."
   (interactive "p")
@@ -842,7 +849,7 @@ Return nil if can't move."
            (delete-char arg))
 
           ((looking-at lispy-right)
-           (lispy-out-backward 1))
+           (lispy-left 1))
 
           ((looking-at lispy-left)
            (when (looking-back "\\(?:\\s-\\|^\\)[`',@]+")
@@ -1400,7 +1407,7 @@ to all the functions, while maintaining the parens in a pretty state."
           ((looking-back lispy-right))
           ((looking-at lispy-right)
            (when (looking-back " ")
-             (lispy-out-forward 1)))
+             (lispy-right 1)))
           ((looking-at lispy-left)
            (lispy-different))
           ((looking-back "^ +")
@@ -1838,7 +1845,7 @@ When ARG is more than 1, pull ARGth expression to enclose current sexp."
          (lispy-different)
          (setq beg (point))
          (setq end (lispy--out-forward arg))
-         (lispy-out-forward 1)
+         (lispy-right 1)
          (lispy--swap-regions (cons beg end)
                               (cons (point) (point)))
          (lispy--reindent (1+ arg))))
@@ -1883,7 +1890,7 @@ When ARG is more than 1, pull ARGth expression to enclose current sexp."
              (delete-char 1)
              (lispy-save-excursion
                (forward-char 1)
-               (lispy-out-backward 2)
+               (lispy-left 2)
                (lispy--normalize-1))))
           ((and (setq bnd (lispy--bounds-string))
                 (or (save-excursion
@@ -1917,7 +1924,7 @@ When ARG is more than 1, pull ARGth expression to enclose current sexp."
                    (lispy--out-forward 1))
              (insert ")(")
              (backward-char 2)
-             (lispy-out-forward 1))
+             (lispy-right 1))
            (newline-and-indent)
            (when (looking-at lispy-left)
              (indent-sexp))))))
@@ -2845,7 +2852,7 @@ With ARG, use the contents of `lispy-store-region-and-buffer' instead."
                  (if (looking-back lispy-right)
                      (progn (backward-list)
                             nil)
-                   (lispy-out-backward 1))))
+                   (lispy-left 1))))
          (bnd (lispy--bounds-list))
          (str (lispy--string-dwim bnd))
          (expr (lispy--read str))
@@ -2911,7 +2918,7 @@ With ARG, use the contents of `lispy-store-region-and-buffer' instead."
   (lispy-move-down 1)
   (iedit-mode)
   (deactivate-mark)
-  (lispy-out-backward 1)
+  (lispy-left 1)
   (lispy-delete 1)
   (save-excursion
     (lispy--out-backward 1)
@@ -3076,7 +3083,7 @@ Second region and buffer are the current ones."
   (interactive)
   (if (bound-and-true-p edebug-active)
       (save-excursion
-        (lispy-out-backward 99)
+        (lispy-left 99)
         (if (looking-at
              "(\\(?:cl\\|\\)def\\(?:un\\|macro\\)\\s-+\\_<[^ ]+\\_>\\s-+(")
             (progn
@@ -3549,7 +3556,7 @@ First, try to return `lispy--bounds-string'."
 
 ;;* Utilities: movement
 (defvar lispy-ignore-whitespace nil
-  "When set to t, `lispy-out-forward' will not clean up whitespace.")
+  "When set to t, `lispy-right' will not clean up whitespace.")
 
 (defun lispy--out-forward (arg)
   "Move outside list forwards ARG times.
@@ -5225,7 +5232,7 @@ FUNC is obtained from (`lispy--insert-or-call' DEF PLIST)"
   ;; ——— globals: navigation ——————————————————
   (define-key map (kbd "]") 'lispy-forward)
   (define-key map (kbd "[") 'lispy-backward)
-  (define-key map (kbd ")") 'lispy-out-forward-nostring)
+  (define-key map (kbd ")") 'lispy-right-nostring)
   ;; ——— globals: kill-related ————————————————
   (define-key map (kbd "C-k") 'lispy-kill)
   (define-key map (kbd "C-y") 'lispy-yank)
@@ -5257,7 +5264,7 @@ FUNC is obtained from (`lispy--insert-or-call' DEF PLIST)"
   (when lispy-use-ctrl-digits
     (define-key map (kbd "C-1") 'lispy-describe-inline)
     (define-key map (kbd "C-2") 'lispy-arglist-inline)
-    (define-key map (kbd "C-3") 'lispy-out-forward)
+    (define-key map (kbd "C-3") 'lispy-right)
     (define-key map (kbd "C-4") lispy-mode-x-map)
     (define-key map (kbd "C-7") 'lispy-cursor-down)
     (define-key map (kbd "C-8") 'lispy-parens-down)
@@ -5271,8 +5278,8 @@ FUNC is obtained from (`lispy--insert-or-call' DEF PLIST)"
   (define-key map (kbd "M-q") 'lispy-fill)
   (define-key map (kbd "<backtab>") 'lispy-shifttab)
   ;; ——— locals: navigation ———————————————————
-  (lispy-define-key map "l" 'lispy-out-forward)
-  (lispy-define-key map "h" 'lispy-out-backward)
+  (lispy-define-key map "l" 'lispy-right)
+  (lispy-define-key map "h" 'lispy-left)
   (lispy-define-key map "f" 'lispy-flow)
   (lispy-define-key map "j" 'lispy-down)
   (lispy-define-key map "k" 'lispy-up)