Merge branch 'main' into issue-746-macro-eval-pass

Author: borkdude

src/nextjournal/clerk/analyzer.clj

@@ -539,8 +539,7 @@
         init-state (if ran-macros?
                      (init-state-fn)
                      init-state)]
-    (loop [{:as state :keys [->analysis-info analyzed-file-set counter]}
-           init-state]
+    (loop [{:as state :keys [->analysis-info analyzed-file-set counter]} init-state]
       (let [unhashed (unhashed-deps ->analysis-info)
             loc->syms (apply dissoc
                              (group-by find-location unhashed)
@@ -569,6 +568,16 @@
               make-deps-inherit-no-cache
               (dissoc :analyzed-file-set :counter)))))))
 
+(comment
+  (reset! !file->analysis-cache {})
+
+  (def parsed (parser/parse-file {:doc? true} "src/nextjournal/clerk/webserver.clj"))
+  (def analysis (time (-> parsed analyze-doc build-graph)))
+  (-> analysis :->analysis-info keys set)
+  (let [{:keys [->analysis-info]} analysis]
+    (dissoc (group-by find-location (unhashed-deps ->analysis-info)) nil))
+  (nextjournal.clerk/clear-cache!))
+
 #_(do (time (build-graph (parser/parse-clojure-string (slurp "notebooks/how_clerk_works.clj")))) :done)
 #_(do (time (build-graph (parser/parse-clojure-string (slurp "notebooks/viewer_api.clj")))) :done)
 
@@ -595,8 +604,7 @@
 
 
 (defn ^:private canonicalize-form
-  "Undoes the non-deterministic transformations done by the splicing
-  reader macro."
+  "Undoes the non-deterministic transformations done by the splicing reader macro."
   [form]
   (walk/postwalk (fn [f]
                    (if-let [orig-name (and (simple-symbol? f)
@@ -612,7 +620,7 @@
 
 (defn hash-codeblock [->hash {:keys [ns graph record-missing-hash-fn]} {:as codeblock :keys [hash form id vars graph-node]}]
   (let [deps (when id (dep/immediate-dependencies graph id))
-        hashed-deps (into #{} (keep ->hash) deps)]
+        hashed-deps (into (sorted-set) (keep ->hash) deps)]
     ;; NOTE: missing hashes on deps might occur e.g. when some dependencies are interned at runtime
     (when record-missing-hash-fn
       (when-some [dep-with-missing-hash
@@ -623,9 +631,14 @@
         (record-missing-hash-fn (assoc codeblock
                                        :dep-with-missing-hash dep-with-missing-hash
                                        :graph-node graph-node :ns ns))))
-    (sha1-base58 (binding [*print-length* nil]
-                   (pr-str (set/union (conj hashed-deps (if form (-> form remove-type-meta canonicalize-form) hash))
-                                      vars))))))
+    (binding [*print-length* nil]
+      (let [form-with-deps-sorted
+            (-> hashed-deps
+                (conj (if form
+                        (-> form remove-type-meta canonicalize-form pr-str)
+                        hash))
+                (into (map str) vars))]
+        (sha1-base58 (pr-str form-with-deps-sorted))))))
 
 #_(hash-codeblock {} {:graph (dep/graph)} {})
 #_(hash-codeblock {} {:graph (dep/graph)} {:hash "foo"})

src/nextjournal/clerk/parser.cljc

@@ -34,7 +34,6 @@
 (defn read-string [s]
   (edamame/parse-string s {:all true
                            :read-cond :allow
-                           :regex #(list `re-pattern %)
                            :features #?(:bb #{:bb :clj}
                                         :default #{:clj})
                            :end-location false

test/nextjournal/clerk/analyzer_test.clj

@@ -302,13 +302,25 @@
       (is (not (:no-cache? (get ->analysis-info 'nextjournal.clerk.analyzer-test.redefs/a#2))))))
 
 
-  (testing "hashing is determistics for splicing reader macros"
+  (testing "hashing is deterministic for auto-gensym-ed symbols in syntax-quote"
     (let [hash-single-form (fn [form]
                              (ana/hash-codeblock {} {:graph (dep/graph)} (ana/analyze form)))]
       (is (= (hash-single-form `(let [a# 1]
                                   (inc a#)))
              (hash-single-form `(let [a# 1]
-                                  (inc a#))))))))
+                                  (inc a#)))))))
+
+  (testing "hashing is deterministic for regexes"
+    (let [regex-graph #(->
+                        (parser/parse-clojure-string "
+(def id identity)
+
+[+ - id #\"my\"]")
+                        (ana/analyze-doc)
+                        (ana/build-graph)
+                        (ana/hash)
+                        :->hash)]
+      (apply = (repeatedly 100 regex-graph)))))
 
 (deftest analyze-doc
   (utils/when-not-bb

test/nextjournal/clerk/eval_test.clj

@@ -310,3 +310,8 @@
           second (do (eval/eval-string ns)
                      @@(resolve 'fixture-ns/state))]
       (is (= [2 0] [first second])))))
+
+(deftest issue-741-can-eval-quoted-regex-test
+  (is (match? {:blocks [{:type :code,
+                         :result {:nextjournal/value "foo"}}]}
+              (eval/eval-string "(re-find '#\"foo\" \"foobar\")"))))

test/nextjournal/clerk/parser_test.clj

@@ -167,10 +167,6 @@ par two"))))
            "^{:un :balanced :map} (do nothing)"))))
 
 (deftest read-string-tests
-  (testing "read-string should read regex's such that value equalility is preserved"
-    (is (= '(fn [x] (clojure.string/split x (clojure.core/re-pattern "/")))
-           (parser/read-string "(fn [x] (clojure.string/split x #\"/\"))"))))
-
   (testing "read-string can handle syntax quote"
     (is (match? '['nextjournal.clerk.parser-test/foo 'nextjournal.clerk.view/foo 'nextjournal.clerk/foo]
                 (binding [*ns* (find-ns 'nextjournal.clerk.parser-test)]