Exercise transitive deps in test and re-use analyze-doc-deps (#774)

Co-authored-by: Martin Kavalar <martin@nextjournal.com>

Author: borkdude

src/nextjournal/clerk/analyzer.clj

@@ -501,33 +501,12 @@
                 (filter (comp #{:code} :type)
                         blocks))))
 
-(defn transitive-deps
-  ([id analysis-info]
-   (loop [seen #{}
-          deps #{id}
-          res #{}]
-     (if (seq deps)
-       (let [dep (first deps)]
-         (if (contains? seen dep)
-           (recur seen (rest deps) res)
-           (let [{new-deps :deps} (get analysis-info dep)
-                 seen (conj seen dep)
-                 deps (concat (rest deps) new-deps)
-                 res (into res deps)]
-             (recur seen deps res))))
-       res))))
-
-#_(transitive-deps id analysis-info)
-
-#_(transitive-deps :main {:main {:deps [:main :other]}
-                          :other {:deps [:another]}
-                          :another {:deps [:another-one :another :main]}})
-
 (defn run-macros [init-state]
-  (let [{:keys [blocks ->analysis-info]} init-state
+  (let [{:keys [blocks]} init-state
         macro-block-ids (keep #(when (:macro %)
                                  (:id %)) blocks)
-        deps (mapcat #(transitive-deps % ->analysis-info) macro-block-ids)
+        {:keys [graph]} (analyze-doc-deps init-state)
+        deps (mapcat (partial dep/transitive-dependencies graph) macro-block-ids)
         all-block-ids (into (set macro-block-ids) deps)
         all-blocks (filter #(contains? all-block-ids (:id %)) blocks)]
     (doseq [block all-blocks]

test/nextjournal/clerk/eval_test.clj

@@ -294,14 +294,17 @@
     (remove-ns 'fixture-ns)
     (clerk/clear-cache!)
     (let [ns "(ns my-random-namespace)
+(defn helper-compile-time1 [x] x)
+(defn helper-compile-time2 [x] (helper-compile-time1 x))
+
 (defn macro-helper* [x] x)
 
 (defmacro attempt1
   [& body]
+  (helper-compile-time2
   `(macro-helper* (try
                     (do ~@body)
-                    (catch Exception e# e#))))
-
+                    (catch Exception e# e#)))))
 
 (def a1
   (do