Add cycling privacy, collection type, if/if-not

benedekfazekas · benedekfazekas · commit e1b281f45f63 · 2016-05-26T21:30:14.000+01:00
Migrate cycle privacy, cycle collection type and cycle if/if-not
implementations from clj-refactor.el.

Additionally refactor `def-threading-test` macro to use it for testing
cycling stuff too and fix duplicate test names in
`clojure-mode-refactor-threading-test`
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## master (unreleased)
 
+### New features
+
+* Port cycle privacy, cycle collection type and cycle if/if-not from clj-refactor.el.
+
 ## 5.4.0 (2016-05-21)
 
 ### New features
diff --git a/README.md b/README.md
@@ -31,6 +31,7 @@ specific `clojure-mode` release.**
   - [Vertical alignment](#vertical-alignment)
 - [Refactoring support](#refactoring-support)
   - [Threading macros](#threading-macros-related-features)
+  - [Cycling things](#cycling-things)
 - [Related packages](#related-packages)
 - [REPL Interaction](#repl-interaction)
   - [Basic REPL](#basic-repl)
@@ -258,6 +259,20 @@ argument do not thread the last form. See demonstration on the
 Unwind and remove the threading macro. See demonstration on the
 [clj-refactor.el wiki](https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-unwind-all).
 
+### Cycling things
+
+* Cycle privacy
+
+Cycle privacy of `def`s or `defn`s. Use metadata explicitly with setting `clojure-use-metadata-for-privacy` to `t` for `defn`s too. See demonstration on the [clj-refactor.el wiki](https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-cycle-privacy).
+
+* Cycle collection type
+
+Cycle the collection at point between list, map, vector and set literals. See demonstration on the [clj-refactor.el wiki](https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-cycle-coll).
+
+* Cycle if/if-not
+
+Find the closest if or if-not up the syntax tree and toggle it. Also transpose the "else" and "then" branches, keeping the semantics the same as before. See demonstration on the [clj-refactor.el wiki](https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-cycle-if).
+
 ## Related packages
 
 * [clojure-mode-extra-font-locking][] provides additional font-locking
diff --git a/clojure-mode.el b/clojure-mode.el
@@ -205,6 +205,12 @@ Out-of-the box clojure-mode understands lein, boot and gradle."
     (define-key map (kbd "C-c C-r l") #'clojure-thread-last-all)
     (define-key map (kbd "C-c C-r C-a") #'clojure-unwind-all)
     (define-key map (kbd "C-c C-r a") #'clojure-unwind-all)
+    (define-key map (kbd "C-c C-r C-p") #'clojure-cycle-privacy)
+    (define-key map (kbd "C-c C-r p") #'clojure-cycle-privacy)
+    (define-key map (kbd "C-c C-r C-c") #'clojure-cycle-collection)
+    (define-key map (kbd "C-c C-r c") #'clojure-cycle-collection)
+    (define-key map (kbd "C-c C-r C-i") #'clojure-cycle-if)
+    (define-key map (kbd "C-c C-r i") #'clojure-cycle-if)
     (define-key map (kbd "C-c C-r n i") #'clojure-insert-ns-form)
     (define-key map (kbd "C-c C-r n h") #'clojure-insert-ns-form-at-point)
     (define-key map (kbd "C-c C-r n u") #'clojure-update-ns)
@@ -225,6 +231,10 @@ Out-of-the box clojure-mode understands lein, boot and gradle."
          "--"
          ["Unwind once" clojure-unwind]
          ["Fully unwind a threading macro" clojure-unwind-all])
+        ("Cycle things"
+         ["Cycle privacy" clojure-cycle-privacy]
+         ["Cycle collection type" clojure-cycle-collection]
+         ["Cycle if, if-not" clojure-cycle-if])
         "--"
         ["Clojure-mode version" clojure-mode-display-version]))
     map)
@@ -1629,6 +1639,8 @@ This will skip over sexps that don't represent objects, so that ^hints and
 ;; Refactoring support
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Threading macros related
 (defcustom clojure-thread-all-but-last nil
   "Non-nil means do not thread the last expression.
 This means that `clojure-thread-first-all' and
@@ -1824,6 +1836,114 @@ When BUT-LAST is passed the last expression is not threaded."
   (interactive "P")
   (clojure--thread-all "->> " but-last))
 
+;;; Cycling stuff
+
+(defcustom clojure-use-metadata-for-privacy nil
+  "If nil, `clojure-cycle-privacy' will use (defn- f []).
+If t, it will use (defn ^:private f [])."
+  :package-version '(clojure-mode . "5.5.0")
+  :safe #'booleanp
+  :type 'boolean)
+
+;;;###autoload
+(defun clojure-cycle-privacy ()
+  "Make public the current private def, or vice-versa.
+
+See: https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-cycle-privacy"
+  (interactive)
+  (save-excursion
+    (ignore-errors (forward-char 7))
+    (search-backward-regexp "\\((defn-? \\)\\|\\((def \\)")
+    (cond
+     ((and clojure-use-metadata-for-privacy
+           (looking-at "(defn ^:private"))
+      (forward-char 5)
+      (delete-char 10))
+     ((and (not clojure-use-metadata-for-privacy)
+           (looking-at "(defn-"))
+      (forward-char 5)
+      (delete-char 1))
+     ((and clojure-use-metadata-for-privacy
+           (looking-at "(defn"))
+      (forward-char 5)
+      (insert " ^:private"))
+     ((and (not clojure-use-metadata-for-privacy)
+           (looking-at "(defn"))
+      (forward-char 5)
+      (insert "-"))
+     ((looking-at "(def ^:private")
+      (forward-char 5)
+      (delete-char 10))
+     ((looking-at "(def ")
+      (forward-char 5)
+      (insert "^:private ")))))
+
+;;;###autoload
+(defun clojure-cycle-collection ()
+  "Convert the coll at (point) from (x) -> {x} -> [x] -> -> #{x} -> (x) recur.
+
+See: https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-cycle-coll"
+  (interactive)
+  (save-excursion
+    (while (and
+            (> (point) 1)
+            (not (eq (string-to-char "(") (char-after)))
+            (not (string= "#{" (buffer-substring (point) (+ 2 (point)))))
+            (not (eq (string-to-char "{") (char-after)))
+            (not (eq (string-to-char "[") (char-after))))
+      (backward-char))
+
+    (cond
+     ((eq (string-to-char "(") (char-after))
+      (insert "{" (substring (clojure-delete-and-extract-sexp) 1 -1) "}"))
+
+     ((eq (string-to-char "#") (char-after))
+      (delete-char 1)
+      (insert "(" (substring (clojure-delete-and-extract-sexp) 1 -1) ")"))
+
+     ((eq (string-to-char "{") (char-after))
+      (if (not (equal (string-to-char "#") (char-before)))
+          (insert "[" (substring (clojure-delete-and-extract-sexp) 1 -1) "]")
+        (backward-char)
+        (delete-char 1)
+        (insert "(" (substring (clojure-delete-and-extract-sexp) 1 -1) ")")))
+
+     ((eq (string-to-char "[") (char-after))
+      (insert "#{" (substring (clojure-delete-and-extract-sexp) 1 -1) "}"))
+
+     ((equal 1 (point))
+      (user-error "Beginning of file reached, collection is not found")))))
+
+(defun clojure--goto-if ()
+  (when (in-string-p)
+    (while (or (not (looking-at "("))
+               (in-string-p))
+      (backward-char)))
+  (while (not (looking-at "\\((if \\)\\|\\((if-not \\)"))
+    (condition-case nil
+        (backward-up-list)
+      (scan-error (user-error "No if or if-not found")))))
+
+;;;###autoload
+(defun clojure-cycle-if ()
+  "Change a surrounding if to if-not, or vice-versa.
+
+See: https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-cycle-if"
+  (interactive)
+  (save-excursion
+    (clojure--goto-if)
+    (cond
+     ((looking-at "(if-not")
+      (forward-char 3)
+      (delete-char 4)
+      (forward-sexp 2)
+      (transpose-sexps 1))
+     ((looking-at "(if")
+      (forward-char 3)
+      (insert "-not")
+      (forward-sexp 2)
+      (transpose-sexps 1)))))
+
 
 ;;; ClojureScript
 (defconst clojurescript-font-lock-keywords
diff --git a/test/clojure-mode-cycling-test.el b/test/clojure-mode-cycling-test.el
@@ -0,0 +1,142 @@
+;;; clojure-mode-cycling-test.el --- Clojure Mode: cycling things tests  -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2016 Benedek Fazekas <benedek.fazekas@gmail.com>
+
+;; This file is not part of GNU Emacs.
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; The cycling privacy, collection type and if/if-not code is ported from
+;; clj-refactor.el and the work of the clj-reafctor.el team.
+
+;;; Code:
+
+(require 'clojure-mode)
+(require 'ert)
+
+(def-refactor-test test-cycle-privacy-public-defn-private-defn
+  "(defn add [a b]
+  (+ a b))"
+  "(defn- add [a b]
+  (+ a b))"
+  (clojure-cycle-privacy))
+
+(def-refactor-test test-cycle-privacy-from-sexp-beg
+  "(defn- add [a b]
+  (+ a b))"
+  "(defn add [a b]
+  (+ a b))"
+  (backward-sexp)
+  (clojure-cycle-privacy))
+
+(def-refactor-test test-cycle-privacy-public-defn-private-defn-metadata
+  "(defn add [a b]
+  (+ a b))"
+  "(defn ^:private add [a b]
+  (+ a b))"
+  (let ((clojure-use-metadata-for-privacy t))
+      (clojure-cycle-privacy)))
+
+(def-refactor-test test-cycle-privacy-private-defn-public-defn
+  "(defn- add [a b]
+  (+ a b))"
+  "(defn add [a b]
+  (+ a b))"
+  (clojure-cycle-privacy))
+
+(def-refactor-test test-cycle-privacy-private-defn-public-defn-metadata
+  "(defn ^:private add [a b]
+  (+ a b))"
+  "(defn add [a b]
+  (+ a b))"
+  (let ((clojure-use-metadata-for-privacy t))
+    (clojure-cycle-privacy)))
+
+(def-refactor-test test-cycle-privacy-public-def-private-def
+  "(def ^:dynamic config
+  \"docs\"
+  {:env \"staging\"})"
+  "(def ^:private ^:dynamic config
+  \"docs\"
+  {:env \"staging\"})"
+  (clojure-cycle-privacy))
+
+(def-refactor-test test-cycle-privacy-private-def-public-def
+  "(def ^:private config
+  \"docs\"
+  {:env \"staging\"})"
+  "(def config
+  \"docs\"
+  {:env \"staging\"})"
+  (clojure-cycle-privacy))
+
+(def-refactor-test test-cycle-collection-list-map
+  "(:a 1 :b 2)"
+  "{:a 1 :b 2}"
+  (backward-sexp)
+  (clojure-cycle-collection))
+
+(def-refactor-test test-cycle-collection-map-vector
+  "{:a 1 :b 2}"
+  "[:a 1 :b 2]"
+  (backward-sexp)
+  (clojure-cycle-collection))
+
+(def-refactor-test test-cycle-collection-vector-set
+  "[1 2 3]"
+  "#{1 2 3}"
+  (backward-sexp)
+  (clojure-cycle-collection))
+
+(def-refactor-test test-cycle-collection-set-list
+  "#{1 2 3}"
+  "(1 2 3)"
+  (backward-sexp)
+  (clojure-cycle-collection))
+
+(def-refactor-test test-cycle-if-inner-if
+  "(if this
+  (if that
+    (then AAA)
+    (else BBB))
+  (otherwise CCC))"
+  "(if this
+  (if-not that
+    (else BBB)
+    (then AAA))
+  (otherwise CCC))"
+  (beginning-of-buffer)
+  (search-forward "BBB)")
+  (clojure-cycle-if))
+
+(def-refactor-test test-cycle-if-outer-if
+  "(if-not this
+  (if that
+    (then AAA)
+    (else BBB))
+  (otherwise CCC))"
+  "(if this
+  (otherwise CCC)
+  (if that
+    (then AAA)
+    (else BBB)))"
+  (beginning-of-buffer)
+  (search-forward "BBB))")
+  (clojure-cycle-if))
+
+(provide 'clojure-mode-cycling-test)
+
+;;; clojure-mode-cycling-test.el ends here
diff --git a/test/clojure-mode-refactor-threading-test.el b/test/clojure-mode-refactor-threading-test.el
diff --git a/test/test-helper.el b/test/test-helper.el
