Clerk in Babashka

.clj-kondo/config.edn

@@ -7,7 +7,8 @@
            taoensso.encore/defonce clojure.core/defonce
            taoensso.encore/defalias clojure.core/def
            promesa.core/let clojure.core/let
-           shadow.cljs.modern/defclass clojure.core/defprotocol}
+           shadow.cljs.modern/defclass clojure.core/defprotocol
+           nextjournal.clerk.utils/if-bb clojure.core/if}
  :linters {:clojure-lsp/unused-public-var {:level :off}
            :consistent-alias {:aliases {datomic.api datomic
                                         clojure.string str

bb-runtime.edn

@@ -0,0 +1,25 @@
+{:min-bb-version "1.12.202"
+ :paths ["notebooks" "resources" "test"]
+ :deps {io.github.nextjournal/clerk {:local/root "."}
+        mvxcvi/multiformats {:mvn/version "1.0.125"}}
+ :tasks
+ {:init (do (require '[babashka.fs :as fs])
+            (System/setProperty "clerk.resource_manifest" (str {"/js/viewer.js" "/js/viewer.js"})))
+  dev
+  {:requires ([babashka.nrepl.server :as srv]
+              [nextjournal.clerk :as clerk]
+              [babashka.cli :as cli])
+   :task (do (srv/start-server! {:host "localhost" :port 1339})
+             (spit ".nrepl-port" "1339")
+             (nextjournal.clerk/serve! (cli/parse-opts *command-line-args*))
+             (-> (Runtime/getRuntime)
+               (.addShutdownHook (Thread. (fn []
+                                            (nextjournal.clerk/halt!)
+                                            (fs/delete ".nrepl-port")))))
+             (deref (promise)))}
+
+  build
+  {:requires ([nextjournal.clerk :as clerk]
+              [babashka.cli :as cli])
+   :task (let [spec (-> (resolve 'nextjournal.clerk/build!) meta :org.babashka/cli)]
+           (clerk/build! (cli/parse-opts *command-line-args* spec)))}}}

bb.edn

@@ -56,6 +56,14 @@
                                clojure (str ":" clojure-version))
                      *command-line-args*))}
 
+  test:bb {:doc "Run babashka tests"
+           :extra-paths ["test"]
+           :extra-deps {io.github.nextjournal/clerk {:local/root "."}
+                        nubank/matcher-combinators {:mvn/version "3.5.1"}
+                        org.clojure/test.check {:mvn/version "1.1.1"}
+                        io.github.cognitect-labs/test-runner {:git/tag "v0.5.1" :git/sha "dfb30dd"}}
+           :task cognitect.test-runner/-main}
+
   playwright:version {:doc "Print used playwright version from ui_tests/yarn.json"
                       :task (print (->> (babashka.process/shell {:out :string} "grep -E 'playwright-core \"(.*)\"' ui_tests/yarn.lock")
                                         :out

deps.edn

@@ -1,19 +1,20 @@
 {:paths ["src" "resources" "bb"]
- :deps {org.clojure/clojure {:mvn/version "1.10.3"}
+ :deps {org.clojure/clojure {:mvn/version "1.11.1"}
         org.clojure/java.classpath {:mvn/version "1.0.0"}
         babashka/fs {:mvn/version "0.5.22"}
         borkdude/edamame {:mvn/version "1.4.28"}
         weavejester/dependency {:mvn/version "0.2.1"}
         com.nextjournal/beholder {:mvn/version "1.0.2"}
         org.flatland/ordered {:mvn/version "1.15.12"}
-        io.github.nextjournal/markdown {:mvn/version "0.7.184"}
+        io.github.nextjournal/markdown {:mvn/version "0.7.186"}
         babashka/process {:mvn/version "0.4.16"}
         io.github.nextjournal/dejavu {:git/sha "4980e0cc18c9b09fb220874ace94ba6b57a749ca"}
         io.github.babashka/sci.nrepl {:mvn/version "0.0.2"}
 
         com.taoensso/nippy {:mvn/version "3.4.2"}
 
-        mvxcvi/multiformats {:mvn/version "0.3.107"}
+        mvxcvi/multiformats {:mvn/version "1.0.125"}
+        mvxcvi/alphabase {:mvn/version "3.0.185"}
         com.pngencoder/pngencoder {:mvn/version "0.13.1"}
 
         http-kit/http-kit {:mvn/version "2.8.0"}

notebooks/babashka.clj

@@ -0,0 +1,31 @@
+(ns babashka
+  ; {:nextjournal.clerk/no-cache true}
+  (:require [babashka.fs :as fs]
+            [nextjournal.clerk :as clerk]))
+
+(System/getProperty "babashka.version")
+
+*file*
+
+(fs/exists? *file*)
+
+;;;;
+
+;;;; dude
+
+(+ 1 2 3)
+
+(prn :dude)
+
+java.io.File
+
+(def x 2)
+
+(prn x)
+
+(clerk/with-viewer
+  {
+   :render-fn '(fn [_]
+                 [:div {:style {:color "green"}}
+                  "Hello"])}
+  nil)

src/nextjournal/beholder.bb

@@ -0,0 +1,5 @@
+(ns nextjournal.beholder
+  "Babashka runtime no-op stubs")
+
+(defn watch [cb & args] nil)
+(defn stop [w] nil)

src/nextjournal/clerk.clj

@@ -662,3 +662,7 @@
   (clear-cache!)
   (halt!)
   )
+
+(comment
+  (with-cache 1)
+  )

src/nextjournal/clerk/always_array_map.clj

@@ -1,6 +1,7 @@
 (ns nextjournal.clerk.always-array-map
   "A persistent data structure that is based on array-map, but doesn't turn into a hash-map by using assoc etc.
-   Prints like a normal Clojure map in the order of insertion.")
+   Prints like a normal Clojure map in the order of insertion."
+  (:require [nextjournal.clerk.utils :as utils]))
 
 (set! *warn-on-reflection* true)
 
@@ -9,72 +10,113 @@
 
 (declare ->AlwaysArrayMap)
 
-(deftype AlwaysArrayMap [^clojure.lang.PersistentArrayMap the-map]
-  clojure.lang.ILookup
-  (valAt [_ k]
-    (get the-map k))
-
-  clojure.lang.Seqable
-  (seq [_]
-    (seq the-map))
-
-  clojure.lang.IPersistentMap
-  (assoc [_ k v]
-    (if (< (count the-map) 8)
-      (->AlwaysArrayMap (assoc the-map k v))
-      (->AlwaysArrayMap (assoc-after the-map k v))))
-
-  (assocEx [_ _k _v]
-    (throw (ex-info "Not implemented" {})))
-
-  (without [_ k]
-    (->AlwaysArrayMap (dissoc the-map k)))
-
-  clojure.lang.Associative
-  (containsKey [_ k]
-    (contains? the-map k))
-
-  clojure.lang.IPersistentCollection
-  (equiv [_ other]
-    (= the-map other))
-  (count [_]
-    (count the-map))
-
-  java.lang.Iterable
-  (iterator [_]
-    (.iterator the-map))
-
-  clojure.lang.IMeta
-  (meta [_]
-    (meta the-map))
-
-  clojure.lang.IObj
-  (withMeta [_ meta]
-    (->AlwaysArrayMap (with-meta the-map meta)))
-
-  Object
-  (toString [_]
-    "<always-array-map>"))
+;; (defn ->LazyMapEntry
+;;   [key_ val_]
+;;   (proxy [clojure.lang.AMapEntry] []
+;;     (key [] key_)
+;;     (val [] (force val_))
+;;     (getKey [] key_)
+;;     (getValue [] (force val_))))
+
+;; (defn ->LazyMap [m]
+;;   (proxy [clojure.lang.APersistentMap clojure.lang.IMeta clojure.lang.IObj]
+;;          []
+;;     (valAt
+;;       ([k]
+;;        (auto-deref (get m k)))
+;;       ([k default-value]
+;;        (auto-deref (get m k default-value))))
+;;     (iterator []
+;;       (.iterator ^java.lang.Iterable
+;;         (eduction
+;;           (map #(->LazyMapEntry % (delay (get this %))))
+;;           (keys m))))
+
+;;     (containsKey [k] (contains? m k))
+;;     (entryAt [k] (if (contains? m k)
+;;                    (->LazyMapEntry k (delay (get this k)))))
+;;     (equiv [other] (= m other))
+;;     (empty [] (->LazyMap (empty m)))
+;;     (count [] (count m))
+;;     (assoc [k v] (->LazyMap (assoc m k v)))
+;;     (without [k] (->LazyMap (dissoc m k)))
+;;     (seq [] (some->> (keys m)
+;;               (map #(->LazyMapEntry % (delay (get this %))))))
+;;     ; a lot of map users expect meta to work
+;;     (meta [] (meta m))
+;;     (withMeta [meta] (->LazyMap (with-meta m meta)))))
+
+
+(utils/if-bb
+ nil
+ (deftype AlwaysArrayMap [^clojure.lang.PersistentArrayMap the-map]
+   clojure.lang.ILookup
+   (valAt [_ k]
+     (get the-map k))
+
+   clojure.lang.Seqable
+   (seq [_]
+     (seq the-map))
+
+   clojure.lang.IPersistentMap
+   (assoc [_ k v]
+     (if (< (count the-map) 8)
+       (->AlwaysArrayMap (assoc the-map k v))
+       (->AlwaysArrayMap (assoc-after the-map k v))))
+
+   (assocEx [_ _k _v]
+     (throw (ex-info "Not implemented" {})))
+
+   (without [_ k]
+     (->AlwaysArrayMap (dissoc the-map k)))
+
+   clojure.lang.Associative
+   (containsKey [_ k]
+     (contains? the-map k))
+
+   clojure.lang.IPersistentCollection
+   (equiv [_ other]
+     (= the-map other))
+   (count [_]
+     (count the-map))
+
+   java.lang.Iterable
+   (iterator [_]
+     (.iterator the-map))
+
+   clojure.lang.IMeta
+   (meta [_]
+     (meta the-map))
+
+   clojure.lang.IObj
+   (withMeta [_ meta]
+     (->AlwaysArrayMap (with-meta the-map meta)))
+
+   Object
+   (toString [_]
+     "<always-array-map>")))
 
 (defn assoc-before [aam k v]
   (->AlwaysArrayMap (apply array-map (list* k v (interleave (keys aam) (vals aam))))))
 
 (defn always-array-map [& kvs]
   (->AlwaysArrayMap (apply array-map kvs)))
 
-(defmethod print-method AlwaysArrayMap
-  [v ^java.io.Writer writer]
-  (.write writer "{")
-  (let [write-kv! (fn [k v]
-              (.write writer (pr-str k))
-              (.write writer " ")
-              (.write writer (pr-str v)))]
-    (doseq [[k v] (butlast v)]
-      (write-kv! k v)
-      (.write writer ", "))
-    (let [[k v] (last v)]
-      (write-kv! k v)))
-  (.write writer "}"))
+(utils/if-bb
+ nil
+ (defmethod print-method AlwaysArrayMap
+   [v ^java.io.Writer writer]
+   (.write writer "{")
+   (let [write-kv! (fn [k v]
+                     (.write writer (pr-str k))
+                     (.write writer " ")
+                     (.write writer (pr-str v)))]
+     (doseq [[k v] (butlast v)]
+       (write-kv! k v)
+       (.write writer ", "))
+     (let [[k v] (last v)]
+       (write-kv! k v)))
+   (.write writer "}")))
 
 (comment
   (pr-str (always-array-map 1 2))

src/nextjournal/clerk/analyzer.clj

@@ -6,16 +6,18 @@
             [clojure.java.io :as io]
             [clojure.set :as set]
             [clojure.string :as str]
-            [multiformats.base.b58 :as b58]
             [multiformats.hash :as hash]
             [nextjournal.clerk.analyzer.impl :as ana :refer [analyze*]]
             [nextjournal.clerk.classpath :as cp]
             [nextjournal.clerk.config :as config]
             [nextjournal.clerk.parser :as parser]
+            [nextjournal.clerk.utils :as utils]
             [nextjournal.clerk.walk :as walk]
-            [taoensso.nippy :as nippy]
             [weavejester.dependency :as dep]))
 
+(when-not utils/bb?
+  (require '[taoensso.nippy :as nippy]))
+
 (set! *warn-on-reflection* true)
 
 (defn deref? [form]
@@ -42,10 +44,10 @@
 #_(no-cache? '^{:nextjournal.clerk/no-cache false} (def ^:nextjournal.clerk/no-cache my-rand (rand-int 10)))
 
 (defn sha1-base58 [s]
-  (->> s hash/sha1 hash/encode b58/format-btc))
+  (->> s hash/sha1 hash/encode (utils/->base58)))
 
 (defn sha2-base58 [s]
-  (->> s hash/sha2-512 hash/encode b58/format-btc))
+  (->> s hash/sha2-512 hash/encode (utils/->base58)))
 
 #_(sha1-base58 "hello")
 
@@ -80,7 +82,9 @@
                          e)))))))
 
 (defn analyze-form [form]
-  (with-bindings {clojure.lang.Compiler/LOADER (clojure.lang.RT/makeClassLoader)}
+  (with-bindings (utils/if-bb
+                   {}
+                   {clojure.lang.Compiler/LOADER (clojure.lang.RT/makeClassLoader)})
     (binding [ana/*deps* (or ana/*deps* (atom #{}))]
       (analyze-form* (rewrite-defcached form)))))
 
@@ -453,7 +457,7 @@
         (if-let [ns (and (qualified-symbol? sym) (-> sym namespace symbol find-ns))]
           (or (ns->file ns)
               (ns->jar ns))
-          (symbol->jar sym)))))
+          (utils/if-bb nil (symbol->jar sym))))))
 
 #_(find-location `inc)
 #_(find-location `*print-dup*)
@@ -646,10 +650,12 @@
    (let [digest-fn (case hash-type
                      :sha1 sha1-base58
                      :sha512 sha2-base58)]
-     (binding [nippy/*incl-metadata?* false]
-       (-> value
-           nippy/fast-freeze
-           digest-fn)))))
+     (utils/if-bb (-> value pr-str digest-fn)
+                  #_{:clj-kondo/ignore [:unresolved-namespace]}
+                  (binding [nippy/*incl-metadata?* false]
+                    (-> value
+                        nippy/fast-freeze
+                        digest-fn))))))
 
 #_(valuehash (range 100))
 #_(valuehash :sha1 (range 100))
@@ -674,7 +680,6 @@
                                               (assoc-in state [:->hash deref-dep] (->hash-str (eval deref-dep))))
                                             analyzed-doc
                                             (sort topo-comp deref-deps-to-eval))]
-      #_(prn :hash-deref-deps/form form :deref-deps deref-deps-to-eval)
       (hash doc-with-deref-dep-hashes (sort topo-comp (dep/transitive-dependents-set graph deref-deps-to-eval))))
     analyzed-doc))