Invoke rewrite-clj only when tests are run

While diagnosing a reader behaviour, I noticed that many tests
namespaces were effecting calls to rewrite-clj at namespace load
time.

Moved to always scope vars within tests so that rewrite-clj is only
invoked when tests are actually run.

Author: lread

test/rewrite_clj/examples/cljx_test.cljc

@@ -101,11 +101,11 @@
     (z/root-string
      (cljx-walk zloc active-profiles))))
 
-(let [data (str "(defn debug-inc\n"
-                "  [x]\n"
-                "  #+debug (println #-compact :debug 'inc x)\n"
-                "  (inc x))")]
-  (deftest t-cljx
+(deftest t-cljx
+  (let [data (str "(defn debug-inc\n"
+                  "  [x]\n"
+                  "  #+debug (println #-compact :debug 'inc x)\n"
+                  "  (inc x))")]
     (are [?profiles ?result]
          (is (= ?result (cljx-string data ?profiles)))
       #{}

test/rewrite_clj/regression_test.cljc

@@ -1,61 +1,60 @@
 (ns rewrite-clj.transform-test
   (:require [clojure.string :as string]
-            [clojure.test :refer [deftest is]]
+            [clojure.test :refer [deftest testing is]]
             [rewrite-clj.zip :as z]))
 
-(def data-string
-  (str ";; This is a Project File.\n"
-       "(defproject my-project \"0.1.0-SNAPSHOT\"\n"
-       "  :description \"A project.\n"
-       "                 Multiline!\"\n"
-       "  :dependencies [[a \"0.1.0\"]\n"
-       "                 [b \"1.2.3\"]]\n"
-       "  :repositories { \"private\" \"http://private.com/repo\" })"))
+(deftest t-transform
+  (let [data-string (str ";; This is a Project File.\n"
+                         "(defproject my-project \"0.1.0-SNAPSHOT\"\n"
+                         "  :description \"A project.\n"
+                         "                 Multiline!\"\n"
+                         "  :dependencies [[a \"0.1.0\"]\n"
+                         "                 [b \"1.2.3\"]]\n"
+                         "  :repositories { \"private\" \"http://private.com/repo\" })")
+        data (z/of-string data-string)]
 
-(def data (z/of-string data-string))
+    (testing "simple transformation"
+      (is (= (string/replace data-string "SNAPSHOT" "SNAPSHOT-1")
+             (-> data
+                 (z/find-value z/next 'defproject)
+                 z/right z/right
+                 (z/edit #(str % "-1"))
+                 z/root-string))))
 
-(deftest t-a-simple-transformation
-  (is (= (string/replace data-string "SNAPSHOT" "SNAPSHOT-1")
-         (-> data
-             (z/find-value z/next 'defproject)
-             z/right z/right
-             (z/edit #(str % "-1"))
-             z/root-string))))
+    (testing "seq transformation prefix"
+      (is (= (-> data-string
+                 (string/replace "[a " "[prefix-a ")
+                 (string/replace "[b " "[prefix-b "))
+             (-> data
+                 (z/find-value z/next 'defproject)
+                 (z/find-value :dependencies) z/right
+                 (->>
+                  (z/map
+                   (fn [loc]
+                     (-> loc z/down
+                         (z/prefix "prefix-")
+                         z/up))))
+                 z/root-string))))
 
-(deftest t-a-seq-transformation-prefix
-  (is (= (-> data-string
-             (string/replace "[a " "[prefix-a ")
-             (string/replace "[b " "[prefix-b "))
-         (-> data
-             (z/find-value z/next 'defproject)
-             (z/find-value :dependencies) z/right
-             (->>
-              (z/map
-               (fn [loc]
-                 (-> loc z/down
-                     (z/prefix "prefix-")
-                     z/up))))
-             z/root-string))))
+    (testing "seq transformation suffix"
+      (is (= (-> data-string
+                 (string/replace "[a " "[a-suffix ")
+                 (string/replace "[b " "[b-suffix "))
+             (-> data
+                 (z/find-value z/next 'defproject)
+                 (z/find-value :dependencies) z/right
+                 (->>
+                  (z/map
+                   (fn [loc]
+                     (-> loc z/down
+                         (z/suffix "-suffix")
+                         z/up))))
+                 z/root-string))))
 
-(deftest t-a-seq-transformation-suffix
-  (is (= (-> data-string
-             (string/replace "[a " "[a-suffix ")
-             (string/replace "[b " "[b-suffix "))
-         (-> data
-             (z/find-value z/next 'defproject)
-             (z/find-value :dependencies) z/right
-             (->>
-              (z/map
-               (fn [loc]
-                 (-> loc z/down
-                     (z/suffix "-suffix")
-                     z/up))))
-             z/root-string))))
-
-(deftest t-whitespace-handling-in-removal
-  (is (= (string/replace data-string #"\[a [^\s]+\]\s+" "")
-         (-> data
-             (z/find-value z/next 'defproject)
-             (z/find-value :dependencies)
-             z/right z/down z/remove
-             z/root-string))))
+    (testing "whitespace handling in removal"
+      (is (= (string/replace data-string #"\[a [^\s]+\]\s+" "")
+             (-> data
+                 (z/find-value z/next 'defproject)
+                 (z/find-value :dependencies)
+                 z/right z/down z/remove
+                 z/root-string))))))

test/rewrite_clj/transform_test.cljc

@@ -3,13 +3,13 @@
             [rewrite-clj.node :as node]
             [rewrite-clj.zip :as z]))
 
-(let [n (node/forms-node
-         [(node/spaces 3)
-          (node/coerce [[1 2] 3])])
-      s "   [[1 2] 3]"]
-  (deftest t-edn-for-zipper-creation-from-node
-    (let [loc (z/edn* n)
-          [_ a b c d] (iterate z/next* loc)]
+(deftest t-edn-for-zipper-creation-from-node
+  (let [n (node/forms-node
+           [(node/spaces 3)
+            (node/coerce [[1 2] 3])])
+        s "   [[1 2] 3]"
+        loc (z/edn* n)
+        [_ a b c d] (iterate z/next* loc)]
       (is (= :forms (z/tag loc)))
       (is (= [[1 2] 3] (z/sexpr loc)))
       (is (= :whitespace (z/tag a)))
@@ -20,13 +20,13 @@
       (is (= "[1 2]" (z/string c)))
       (is (= s (with-out-str (z/print loc))))
       (is (= s (with-out-str (z/print-root loc))))
-      (is (every? #{s} (map z/root-string [loc a b c d]))))))
+      (is (every? #{s} (map z/root-string [loc a b c d])))))
 
 #?(:clj
-   (let [f (java.io.File/createTempFile "rewrite" ".clj")
-         s "   [[1 2] 3]"]
-     (spit f s)
-     (deftest t-zipper-creation-with-movement-to-first-non-ws-node
+   (deftest t-zipper-creation-with-movement-to-first-non-ws-node
+     (let [f (java.io.File/createTempFile "rewrite" ".clj")
+           s "   [[1 2] 3]"]
+       (spit f s)
        (are [?loc]
             (let [loc ?loc
                   [_ a b c d] (iterate z/next* loc)]

test/rewrite_clj/zip/base_test.cljc

@@ -1,25 +1,26 @@
 (ns rewrite-clj.zip.editz-test
-  (:require [clojure.test :refer [deftest is are]]
+  (:require [clojure.test :refer [deftest testing is are]]
             [rewrite-clj.node :as node]
             [rewrite-clj.zip :as z]))
 
-(let [root (z/of-string "[1 \"2\" :3]")
-      elements (iterate z/next root)]
-  (deftest t-edit-operations
-    (are [?n ?f ?s]
-         (let [loc (nth elements ?n)
-               loc' (z/edit loc ?f)]
-           (is (= ?s (z/root-string loc'))))
-      0 #(subvec % 1) "[\"2\" :3]"
-      1 #(str % "_x") "[\"1_x\" \"2\" :3]"
-      2 #(keyword % "k") "[1 :2/k :3]"))
-  (deftest t-replace-operations
-    (are [?n ?v ?s]
-         (let [loc (nth elements ?n)
-               loc' (z/replace loc ?v)]
-           (is (= ?s (z/root-string loc'))))
-      0  [1]           "[1]"
-      1  #{0}          "[#{0} \"2\" :3]")))
+(deftest t-edit-operations
+  (let [root (z/of-string "[1 \"2\" :3]")
+        elements (iterate z/next root)]
+    (testing "edit"
+      (are [?n ?f ?s]
+           (let [loc (nth elements ?n)
+                 loc' (z/edit loc ?f)]
+             (is (= ?s (z/root-string loc'))))
+        0 #(subvec % 1) "[\"2\" :3]"
+        1 #(str % "_x") "[\"1_x\" \"2\" :3]"
+        2 #(keyword % "k") "[1 :2/k :3]"))
+    (testing "replace"
+      (are [?n ?v ?s]
+           (let [loc (nth elements ?n)
+                 loc' (z/replace loc ?v)]
+             (is (= ?s (z/root-string loc'))))
+        0  [1]           "[1]"
+        1  #{0}          "[#{0} \"2\" :3]"))))
 
 (deftest t-edit-with-args
   (is (= "[1 102 3]" (-> "[1 2 3]"
@@ -49,9 +50,9 @@
                                      :unexpected))
                           z/root-string)))))
 
-(let [root (z/of-string "[1 [ ] [2 3] [  4  ]]")
-      elements (iterate z/next root)]
-  (deftest t-splice-operations
+(deftest t-splice-operations
+  (let [root (z/of-string "[1 [ ] [2 3] [  4  ]]")
+        elements (iterate z/next root)]
     (are [?n ?s ?e]
          (let [loc (nth elements ?n)
                loc' (z/splice loc)]

test/rewrite_clj/zip/editz_test.cljc

@@ -2,24 +2,24 @@
   (:require [clojure.test :refer [deftest is are]]
             [rewrite-clj.zip :as z]))
 
-(let [root (z/of-string "[ 1 [2 3]   4]")]
   (deftest t-whitespace-aware-movement
-    (are [?ops ?sexpr ?pred]
-         (let [loc ((apply comp (reverse ?ops)) root)]
-           (is (= ?sexpr (z/sexpr loc)))
-           (is (?pred loc)))
-      [z/down]                          1           identity
-      [z/next]                          1           (complement z/end?)
-      [z/next z/next]                   [2 3]       (complement z/end?)
-      [z/down z/right z/right]          4           (complement z/end?)
-      [z/down z/rightmost]              4           z/rightmost?
-      [z/down z/rightmost z/rightmost]  4           z/rightmost?
-      [z/down z/leftmost]               1           z/leftmost?
-      [z/down z/right z/leftmost]       1           z/leftmost?
-      [z/down z/next z/next z/up]       [2 3]       identity
-      [z/down z/next z/next z/up z/up]  [1 [2 3] 4] #(and (z/leftmost? %) (z/rightmost? %))
-      [z/down z/rightmost z/prev]       3           identity
-      [z/down z/rightmost z/next]       4           z/end?)))
+    (let [root (z/of-string "[ 1 [2 3]   4]")]
+      (are [?ops ?sexpr ?pred]
+           (let [loc ((apply comp (reverse ?ops)) root)]
+             (is (= ?sexpr (z/sexpr loc)))
+             (is (?pred loc)))
+        [z/down]                          1           identity
+        [z/next]                          1           (complement z/end?)
+        [z/next z/next]                   [2 3]       (complement z/end?)
+        [z/down z/right z/right]          4           (complement z/end?)
+        [z/down z/rightmost]              4           z/rightmost?
+        [z/down z/rightmost z/rightmost]  4           z/rightmost?
+        [z/down z/leftmost]               1           z/leftmost?
+        [z/down z/right z/leftmost]       1           z/leftmost?
+        [z/down z/next z/next z/up]       [2 3]       identity
+        [z/down z/next z/next z/up z/up]  [1 [2 3] 4] #(and (z/leftmost? %) (z/rightmost? %))
+        [z/down z/rightmost z/prev]       3           identity
+        [z/down z/rightmost z/next]       4           z/end?)))
 
 (deftest t-moving-into-an-empty-inner-node
   (let [zloc (z/of-string "[]")]

test/rewrite_clj/zip/move_test.cljc

@@ -3,22 +3,23 @@
             [rewrite-clj.zip :as z]
             [rewrite-clj.zip.base :as zbase]))
 
-(let [root (z/of-string "[1 #{2 [3 4] 5} 6]")]
-  (deftest t-modifying-subtrees
-    (let [loc (z/subedit-> root
-                           z/next
-                           z/next
-                           z/next
-                           (z/replace* 'x))]
-      (is (= :vector (z/tag loc)))
-      (is (= "[1 #{x [3 4] 5} 6]" (z/string loc)))))
-  (deftest t-modifying-the-whole-tree
-    (let [loc (z/edit-> (-> root z/next z/next z/next)
-                              z/prev z/prev
-                              (z/replace* 'x))]
-      (is (= :token (z/tag loc)))
-      (is (= "2" (z/string loc)))
-      (is (= "[x #{2 [3 4] 5} 6]" (z/root-string loc))))))
+(deftest t-trees
+  (let [root (z/of-string "[1 #{2 [3 4] 5} 6]")]
+    (testing "modifying subtrees"
+      (let [loc (z/subedit-> root
+                             z/next
+                             z/next
+                             z/next
+                             (z/replace* 'x))]
+        (is (= :vector (z/tag loc)))
+        (is (= "[1 #{x [3 4] 5} 6]" (z/string loc)))))
+    (testing "modifying the whole tree"
+      (let [loc (z/edit-> (-> root z/next z/next z/next)
+                          z/prev z/prev
+                          (z/replace* 'x))]
+        (is (= :token (z/tag loc)))
+        (is (= "2" (z/string loc)))
+        (is (= "[x #{2 [3 4] 5} 6]" (z/root-string loc)))))))
 
 (deftest zipper-retains-options
   (let [zloc (z/of-string "(1 (2 (3 4 ::my-kw)))" {:auto-resolve (fn [_x] 'custom-resolved)})

test/rewrite_clj/zip/subedit_test.cljc

@@ -1,43 +1,44 @@
 (ns rewrite-clj.zip.whitespace-test
-  (:require [clojure.test :refer [deftest is are]]
+  (:require [clojure.test :refer [deftest is testing are]]
             [rewrite-clj.node :as node]
             [rewrite-clj.zip :as z]))
 
-(let [space (node/spaces 1)
-      linebreak (node/newlines 1)
-      c0 (node/comment-node "comment")
-      t0 (node/token-node 0)
-      t1 (node/token-node 1)
-      loc (z/edn* (node/forms-node [space linebreak t0 space t1 c0]))]
-  (deftest t-predicates
-    (is (z/whitespace? (-> loc z/down*)))
-    (is (z/linebreak? (-> loc z/down* z/right*)))
-    (is (z/whitespace-or-comment? (-> loc z/down* z/rightmost*))))
-  (deftest t-skipping-whitespace-to-the-right
-    (let [n (-> loc z/down* z/skip-whitespace z/node)]
-      (is (= :token (node/tag n)))
-      (is (= 0 (node/sexpr n)))))
-  (deftest t-skipping-whitespace-to-the-left
-    (let [n (-> loc z/down* z/rightmost* z/skip-whitespace-left z/node)]
-      (is (= :token (node/tag n)))
-      (is (= 1 (node/sexpr n)))))
-  (deftest t-skipping-whitespace-with-a-movement-function
-    (let [n (->> loc z/down* (z/skip-whitespace z/next*) z/node)]
-      (is (= :token (node/tag n)))
-      (is (= 0 (node/sexpr n)))))
-  (deftest t-prepending=appending-spaces
-    (are [?left-fn ?right-fn]
-         (do (let [n (-> loc z/down* z/rightmost* (?left-fn 3))]
-               (is (= " \n0 1   ;comment" (z/root-string n))))
-             (let [n (-> loc z/down* z/rightmost* (?right-fn 3))]
-               (is (= " \n0 1;comment   " (z/root-string n)))))
-      z/prepend-space     z/append-space
-      z/insert-space-left z/insert-space-right))
-  (deftest t-prepending-appending-linebreaks
-    (are [?left-fn ?right-fn]
-         (do (let [n (-> loc z/down* z/rightmost* (?left-fn 3))]
-               (is (= " \n0 1\n\n\n;comment" (z/root-string n))))
-             (let [n (-> loc z/down* z/rightmost* (?right-fn 3))]
-               (is (= " \n0 1;comment\n\n\n" (z/root-string n)))))
-      z/prepend-newline     z/append-newline
-      z/insert-newline-left z/insert-newline-right)))
+(deftest whitespace
+  (let [space (node/spaces 1)
+        linebreak (node/newlines 1)
+        c0 (node/comment-node "comment")
+        t0 (node/token-node 0)
+        t1 (node/token-node 1)
+        loc (z/edn* (node/forms-node [space linebreak t0 space t1 c0]))]
+    (testing "predicates"
+      (is (z/whitespace? (-> loc z/down*)))
+      (is (z/linebreak? (-> loc z/down* z/right*)))
+      (is (z/whitespace-or-comment? (-> loc z/down* z/rightmost*))))
+    (testing "skipping whitespace to the right"
+      (let [n (-> loc z/down* z/skip-whitespace z/node)]
+        (is (= :token (node/tag n)))
+        (is (= 0 (node/sexpr n)))))
+    (testing "skipping whitespace to the left"
+      (let [n (-> loc z/down* z/rightmost* z/skip-whitespace-left z/node)]
+        (is (= :token (node/tag n)))
+        (is (= 1 (node/sexpr n)))))
+    (testing "skipping whitespace with a movement function"
+      (let [n (->> loc z/down* (z/skip-whitespace z/next*) z/node)]
+        (is (= :token (node/tag n)))
+        (is (= 0 (node/sexpr n)))))
+    (testing "prepending appending spaces"
+      (are [?left-fn ?right-fn]
+           (do (let [n (-> loc z/down* z/rightmost* (?left-fn 3))]
+                 (is (= " \n0 1   ;comment" (z/root-string n))))
+               (let [n (-> loc z/down* z/rightmost* (?right-fn 3))]
+                 (is (= " \n0 1;comment   " (z/root-string n)))))
+        z/prepend-space     z/append-space
+        z/insert-space-left z/insert-space-right))
+    (testing "prepending appending linebreaks"
+      (are [?left-fn ?right-fn]
+           (do (let [n (-> loc z/down* z/rightmost* (?left-fn 3))]
+                 (is (= " \n0 1\n\n\n;comment" (z/root-string n))))
+               (let [n (-> loc z/down* z/rightmost* (?right-fn 3))]
+                 (is (= " \n0 1;comment\n\n\n" (z/root-string n)))))
+        z/prepend-newline     z/append-newline
+        z/insert-newline-left z/insert-newline-right))))