Move :changed? up a level

Author: eraserhd

src/rewrite_clj/zip/utils.clj

@@ -7,10 +7,10 @@
   [{:keys [node path parent position] :as loc} k f]
   (let [v (get path k)]
     (if (seq v)
-      {:node node
-       :path (assoc path k (f v) :changed? true)
-       :parent parent
-       :position position}
+      (assoc loc
+             :changed? true
+             :node node
+             :path (assoc path k (f v)))
       loc)))
 
 (defn remove-right
@@ -52,21 +52,17 @@
    location, returns `nil`."
   [{:keys [position parent] {:keys [l] :as path} :path :as loc}]
   (if (seq l)
-    {:node (peek l)
-     :path (-> path
-               (update-in [:l] pop)
-               (assoc :changed? true))
-     :parent parent
-     :position position}))
+    (assoc loc
+           :changed? true
+           :node (peek l)
+           :path (update-in path [:l] pop))))
 
 (defn remove-and-move-right
   "Remove current node and move right. If current node is at the rightmost
    location, returns `nil`."
   [{:keys [position parent] {:keys [r] :as path} :path :as loc}]
   (if (seq r)
-    {:node (first r)
-     :path (-> path
-               (update-in [:r] next)
-               (assoc :changed? true))
-     :parent parent
-     :position position}))
+    (assoc loc
+           :changed? true
+           :node (first r)
+           :path (update-in path [:r] next))))

src/rewrite_clj/zip/zip.clj

@@ -76,18 +76,17 @@
   "Returns the loc of the parent of the node at this loc, or nil if at
   the top"
   [loc]
-  (let [{:keys [node parent position] {:keys [l ppath r changed?]} :path} loc]
+  (let [{:keys [node parent position changed?] {:keys [l ppath r]} :path} loc]
     (when parent
       (if changed?
-        {:node (make-node loc (:node parent) (concat l (cons node r)))
-         :path (and ppath (assoc ppath :changed? true))
-         :parent (:parent parent)
-         :position position}
+        (assoc parent
+               :changed? true
+               :node (make-node loc (:node parent) (concat l (cons node r)))
+               :path ppath)
         parent))))
 
 (defn root
-  "zips all the way up and returns the root node, reflecting any
- changes."
+  "zips all the way up and returns the root node, reflecting any changes."
   [{:keys [end?] :as loc}]
   (if end?
     (node loc)
@@ -101,10 +100,10 @@
   [loc]
   (let [{:keys [node parent position] {l :l [r & rnext :as rs] :r :as path} :path} loc]
     (when (and path rs)
-      {:node r
-       :path (assoc path :l (conj l node) :r rnext)
-       :parent parent
-       :position (node/+extent position (node/extent node))})))
+      (assoc loc
+             :node r
+             :path (assoc path :l (conj l node) :r rnext)
+             :position (node/+extent position (node/extent node))))))
 
 (defn rightmost
   "Returns the loc of the rightmost sibling of the node at this loc, or self"
@@ -118,33 +117,30 @@
   [loc]
   (let [{:keys [node parent position] {:keys [l r] :as path} :path} loc]
     (when (and path (seq l))
-      {:node (peek l)
-       :path (assoc path :l (pop l) :r (cons node r))
-       :parent parent
-       :position position})))
+      (assoc loc
+             :node (peek l)
+             :path (assoc path :l (pop l) :r (cons node r))))))
 
 (defn leftmost
   "Returns the loc of the leftmost sibling of the node at this loc, or self"
   [loc]
   (let [{:keys [node parent position] {:keys [l r] :as path} :path} loc]
     (if (and path (seq l))
-      {:node (first l)
-       :path (assoc path :l [] :r (concat (rest l) [node] r))
-       :parent parent
-       :position position}
+      (assoc loc
+             :node (first l)
+             :path (assoc path :l [] :r (concat (rest l) [node] r)))
       loc)))
 
 (defn insert-left
   "Inserts the item as the left sibling of the node at this loc,
  without moving"
   [loc item]
-    (let [{:keys [node parent position] {:keys [l] :as path} :path} loc]
+    (let [{:keys [parent position] {:keys [l] :as path} :path} loc]
       (if (nil? path)
         (throw (new Exception "Insert at top"))
-        {:node node
-         :path (assoc path :l (conj l item) :changed? true)
-         :parent parent
-         :position position})))
+        (assoc loc
+               :changed? true
+               :path (assoc path :l (conj l item))))))
 
 (defn insert-right
   "Inserts the item as the right sibling of the node at this loc,
@@ -153,18 +149,14 @@
   (let [{:keys [node parent position] {:keys [r] :as path} :path} loc]
     (if (nil? path)
       (throw (new Exception "Insert at top"))
-      {:node node
-       :path (assoc path :r (cons item r) :changed? true)
-       :parent parent
-       :position position})))
+      (assoc loc
+             :changed? true
+             :path (assoc path :r (cons item r))))))
 
 (defn replace
   "Replaces the node at this loc, without moving"
   [loc node]
-  (let [{:keys [path]} loc]
-    (assoc loc
-           :node node
-           :path (assoc path :changed? true))))
+  (assoc loc :changed? true :node node))
 
 (defn edit
   "Replaces the node at this loc with the value of (f node args)"
@@ -222,14 +214,15 @@
     (if (nil? path)
       (throw (new Exception "Remove at top"))
       (if (pos? (count l))
-        (loop [loc {:node (peek l)
-                    :path (assoc path :l (pop l) :changed? true)
-                    :parent parent
-                    :position position}]
+        (loop [loc (assoc loc
+                          :changed? true
+                          :node (peek l)
+                          :path (assoc path :l (pop l)))]
           (if-let [child (and (branch? loc) (down loc))]
             (recur (rightmost child))
             loc))
-        {:node (make-node loc (:node parent) r)
-         :path (and ppath (assoc ppath :changed? true))
-         :parent (:parent parent)
-         :position position}))))
+        (assoc parent
+               :changed? true
+               :node (make-node loc (:node parent) r)
+               :path ppath
+               :parent (:parent parent))))))