make custom zipper identifiable; remove '*-positional-zipper' functions.

Author: Yannick Scherer

src/rewrite_clj/custom_zipper/core.clj

@@ -22,60 +22,40 @@
 ;; To not force users into using this custom zipper, the following flag
 ;; is used to dispatch to `clojure.zip` when set to `false`.
 
-(def ^:dynamic *active?*
-  "Set this to true to activate the custom, position-tracking zipper
-   implementation."
-  false)
+(defn ^:no-doc custom-zipper
+  [root]
+  {::custom? true
+   :node     root
+   :position [1 1]
+   :parent   nil
+   :left     []
+   :right   '()})
 
-(defn use-positional-zipper!
-  "Globally activate the position-tracking zipper. You can locally revert
-   behaviour to `clojure.zip`'s by using `without-positional-zipper`."
-  []
-  (alter-var-root #'*active?* (constantly true)))
+(defn ^:no-doc zipper
+  [root]
+  (clj-zip/zipper
+    node/inner?
+    (comp seq node/children)
+    node/replace-children
+    root))
+
+(defn ^:no-doc custom-zipper?
+  [value]
+  (::custom? value))
 
 (defmacro ^:private defn-switchable
   [sym docstring params & body]
   (let [placeholders (repeatedly (count params) gensym)]
     `(defn ~sym
        ~docstring
        [~@placeholders]
-       (if *active?*
+       (if (custom-zipper? ~(first placeholders))
          (let [~@(interleave params placeholders)]
            ~@body)
          (~(symbol "clojure.zip" (name sym)) ~@placeholders)))))
 
-(defmacro with-positional-zipper
-  "Do not use `clojure.zip` to evaluate any rewrite-clj zipper operations in
-   `body` but a custom position-tracking zipper that offers the function
-   `position` to return row and column of a node."
-  [& body]
-  `(binding [*active?* true]
-     ~@body))
-
-(defmacro without-positional-zipper
-  "Force usage of `clojure.zip` to evaluate any rewrite-clj zipper operations in
-   `body` instead of a custom position-tracking zipper."
-  [& body]
-  `(binding [*active?* false]
-     ~@body))
-
 ;; ## Implementation
 
-(defn ^:no-doc zipper
-  "Creates a new zipper structure."
-  [root]
-  (if *active?*
-    {:node root
-     :position [1 1]
-     :parent nil
-     :left []
-     :right '()}
-    (clj-zip/zipper
-      node/inner?
-      (comp seq node/children)
-      node/replace-children
-      root)))
-
 (defn-switchable node
   "Returns the node at loc"
   [{:keys [node]}]
@@ -102,13 +82,13 @@
 (defn position
   "Returns the ones-based [row col] of the start of the current node"
   [loc]
-  (if *active?*
+  (if (custom-zipper? loc)
     (:position loc)
     (throw
       (IllegalStateException.
         (str
-          "to use the positional zipper functions, please wrap your rewrite-clj"
-          " calls with `rewrite-clj.zip/with-positional-zipper`.")))))
+          "to use the 'position' function, please construct your zipper with "
+           "':track-position?'  set to true.")))))
 
 (defn-switchable lefts
   "Returns a seq of the left siblings of this loc"
@@ -123,11 +103,12 @@
     (let [{:keys [node path] [row col] :position} loc
           [c & cnext :as cs] (children loc)]
       (when cs
-        {:node c
+        {::custom? true
+         :node     c
          :position [row (+ col (node/leader-length node))]
-         :parent loc
-         :left []
-         :right cnext}))))
+         :parent   loc
+         :left     []
+         :right    cnext}))))
 
 (defn-switchable up
   "Returns the loc of the parent of the node at this loc, or nil if at
@@ -227,7 +208,7 @@
 (defn edit
   "Replaces the node at this loc with the value of (f node args)"
   [loc f & args]
-  (if *active?*
+  (if (custom-zipper? loc)
     (replace loc (apply f (node loc) args))
     (apply clj-zip/edit loc f args)))
 

src/rewrite_clj/custom_zipper/utils.clj

@@ -15,7 +15,7 @@
 (defn remove-right
   "Remove right sibling of the current node (if there is one)."
   [loc]
-  (if z/*active?*
+  (if (z/custom-zipper? loc)
     (let [{[r & rs] :right} loc]
       (assoc loc
              :right rs
@@ -25,7 +25,7 @@
 (defn remove-left
   "Remove left sibling of the current node (if there is one)."
   [loc]
-  (if z/*active?*
+  (if (z/custom-zipper? loc)
     (let [{:keys [left]} loc]
       (if-let [[_ lpos] (peek left)]
         (assoc loc
@@ -63,7 +63,7 @@
   "Remove current node and move left. If current node is at the leftmost
    location, returns `nil`."
   [loc]
-  (if z/*active?*
+  (if (z/custom-zipper? loc)
     (let [{:keys [position left]} loc]
       (if (seq left)
         (let [[lnode lpos] (peek left)]
@@ -84,7 +84,7 @@
   "Remove current node and move right. If current node is at the rightmost
    location, returns `nil`."
   [loc]
-  (if z/*active?*
+  (if (z/custom-zipper? loc)
     (let [{:keys [position right]} loc]
       (if (seq right)
         (assoc loc

src/rewrite_clj/zip.clj

@@ -23,10 +23,7 @@
 
 (import-vars
   [rewrite-clj.custom-zipper.core
-   node position root
-   use-positional-zipper!
-   with-positional-zipper
-   without-positional-zipper]
+   node position root]
 
   [rewrite-clj.zip.base
    child-sexprs

src/rewrite_clj/zip/base.clj

@@ -9,19 +9,32 @@
 ;; ## Zipper
 
 (defn edn*
-  "Create zipper over the given Clojure/EDN node."
-  [node]
-  (z/zipper node))
+  "Create zipper over the given Clojure/EDN node.
+
+   If `:track-position?` is set, this will create a custom zipper that will
+   return the current row/column using `rewrite-clj.zip/position`. (Note that
+   this custom zipper will be incompatible with `clojure.zip`'s functions.)"
+  ([node]
+   (edn* node {}))
+  ([node {:keys [track-position?]}]
+   (if track-position?
+     (z/custom-zipper node)
+     (z/zipper node))))
 
 (defn edn
-  "Create zipper over the given Clojure/EDN node and move
-   to the first non-whitespace/non-comment child."
-  [node]
-  (if (= (node/tag node) :forms)
-    (let [top (edn* node)]
-      (or (-> top z/down ws/skip-whitespace)
-          top))
-    (recur (node/forms-node [node]))))
+  "Create zipper over the given Clojure/EDN node and move to the first
+   non-whitespace/non-comment child.
+
+   If `:track-position?` is set, this will create a custom zipper that will
+   return the current row/column using `rewrite-clj.zip/position`. (Note that
+   this custom zipper will be incompatible with `clojure.zip`'s functions.)"
+  ([node] (edn node {}))
+  ([node {:keys [track-position?] :as options}]
+   (if (= (node/tag node) :forms)
+     (let [top (edn* node options)]
+       (or (-> top z/down ws/skip-whitespace)
+           top))
+     (recur (node/forms-node [node]) options))))
 
 ;; ## Inspection
 
@@ -55,13 +68,15 @@
 
 (defn of-string
   "Create zipper from String."
-  [s]
-  (some-> s p/parse-string-all edn))
+  ([s] (of-string s {}))
+  ([s options]
+   (some-> s p/parse-string-all (edn options))))
 
 (defn of-file
   "Create zipper from File."
-  [f]
-  (some-> f p/parse-file-all edn))
+  ([f] (of-file f {}))
+  ([f options]
+   (some-> f p/parse-file-all (edn options))))
 
 ;; ## Write