Improve path generation

Author: MawiraIke

src/lib/devtools/formatters/markup.cljs

@@ -171,6 +171,15 @@
         (conj lines [more-markup])))))
 
 (defn <details> [value starting-index]
+  ;; This is very important when the value is a map
+  ;; we need to push the object to history so that we can be able to get the paths (i.e keys)
+  ;; the other option to this is ignoring this and then when generating paths, assume that all
+  ;; vectors that have two children which are
+  ;; a keyword as the first item and
+  ;; a sequence or map as the second item when the path info is not nil.
+  ;; are all just seq'd maps and that the first item in the vector is a key in the map.
+  ;; The seq'd map is a result of `(seq value)` done in `body-lines` above
+  (devtools.formatters.state/push-object-to-current-history! value)
   (let [has-continuation? (pos? starting-index)
         body-markup (<standard-body> (body-lines value starting-index) has-continuation?)]
     (if has-continuation?

src/lib/devtools/formatters/state.cljs

@@ -46,16 +46,25 @@
 (defn get-last-object-from-current-history []
   (first (get-current-history)))                                                                                              ; note the list is reversed
 
+(defn get-second-last-object-from-current-history []
+  (second (get-current-history)))                                                                                              ; note the list is reversed
+
 (defn present-path-segment [v]
   (cond
     (string? v) v
-    (keyword? v) (str v)
+    ;; we'd like to preserve keywords for easy get
+    (keyword? v) v
     (number? v) v
     :else "?"))
 
 (defn seek-path-segment [coll val]
   (let [* (fn [[k v]]
-            (if (identical? v val)
+            (cond
+              ;; we need to know the paths for keywords, these are clickable
+              (identical? k val)
+              (present-path-segment k)
+
+              (identical? v val)
               (present-path-segment k)))]
     (some * coll)))
 
@@ -64,11 +73,45 @@
     (map? parent-object) (seek-path-segment (seq parent-object) object)
     (sequential? parent-object) (seek-path-segment (map-indexed (fn [i x] [i x]) parent-object) object)))
 
+;; This function checks a unique situation of looping an immediate child element `obj` of a parent element `history`
+;; say we have a general map {:a 2 :b {:gh 45} :c 4}
+;; and we call devtools.formatters.core/body-api-call with the map, the map ends up in
+;; devtools.formatters.markup/<details> which then calls devtools.formatters.markup/body-lines
+;; where the map will get seq'd resulting in ([:a 2] [:b {:gh 45}] [:c 4])
+;; these 3 vectors will then be pushed to history which will result in an issue when generating the path
+;; for example if we are looping over at `obj` as 2 and `history` as `[:a 2]` `build-path-segment` will return
+;; the path as 1 since the immediate history is a vector instead of a map.
+;; This function detects the condition that this is the case and then the next operation will be to
+;; get the first item in the vector which is the path.
+(defn mapping?
+  [history obj]
+  (let [obj-kw (when (and (vector? obj)
+                          (= (count obj) 2)
+                          ;; the map keys must always be one of these
+                          (or
+                            (-> obj first keyword?)
+                            (-> obj first string?)
+                            (-> obj first number?)))
+                 (first obj))]
+    (when (and (map? history) obj-kw)
+      (contains? history obj-kw))))
+
 (defn extend-path-info [path-info object]
   (let [parent-object (get-last-object-from-current-history)]
-    (if-some [path-segment (build-path-segment parent-object object)]
-      (conj (or path-info []) path-segment)
-      path-info)))
+    (cond
+      ;; if the current item we are looping at is an artificial vector (explained at `mapping` above),
+      ;; dont append to the path
+      (and (map? parent-object) (mapping? parent-object object))
+      path-info
+      ;; if the previous item is an artificial vector, lets append to the path info but take the first item
+      ;; in the vector as the path. (Explained in `mapping` above)
+      (and (map? (get-second-last-object-from-current-history))
+           (mapping? (get-second-last-object-from-current-history) parent-object))
+      (conj (or path-info []) (first parent-object))
+      ;; the current object is an item within the parent object
+      (some? (build-path-segment parent-object object))
+      (conj (or path-info []) (build-path-segment parent-object object))
+      :else path-info)))
 
 (defn add-object-to-current-path-info! [object]
   (update-current-state! update :path-info extend-path-info object))