Add compatibility with Babashka (#232)

Currently requires a dev build of Babashka ([6b89b78](babashka/babashka@6b89b78)
  or newer).
---------

Co-authored-by: Michiel Borkent <[email protected]>
Co-authored-by: Martin Kavalar <[email protected]>

Author: 3 people

.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

.github/workflows/main.yml

@@ -71,7 +71,7 @@ jobs:
           - { os: windows-latest, shell: powershell }
         clojure:
           - 1.10.3
-          - 1.12.0
+          - 1.12.1
     defaults:
       run:
         shell: ${{matrix.sys.shell}}
@@ -105,6 +105,53 @@ jobs:
           bb test:clj :kaocha/reporter '[kaocha.report/documentation]' \
           :clojure '"${{ matrix.clojure }}"'
 
+  test-bb:
+    runs-on: ${{matrix.sys.os}}
+
+    strategy:
+      matrix:
+        sys:
+          - { os: macos-latest, shell: bash }
+          - { os: ubuntu-latest, shell: bash }
+          - { os: windows-latest, shell: powershell }
+    defaults:
+      run:
+        shell: ${{matrix.sys.shell}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: 🔧 Install java
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: 🔧 Install clojure
+        uses: DeLaGuardo/setup-clojure@master
+        with:
+          bb: latest
+
+      - name: 🗝 maven cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.m2
+            ~/.gitlibs
+            ~/.deps.clj
+          key: ${{ runner.os }}-maven-test-${{ hashFiles('deps.edn') }}-${{ hashFiles('bb.edn') }}
+      - name: 🔧 Install bb from dev build (until next release)
+        shell: bash
+        run: |
+          curl -sLO https://raw.githubusercontent.com/babashka/babashka/master/install
+          chmod +x ./install
+          ./install --dev-build --dir /tmp
+          cp /tmp/bb "$(which bb)"
+      - name: 🧪 Run tests
+        shell: bash
+        run: |
+          bb test:bb
+
   static-build:
     runs-on: ubuntu-latest
     needs: [build-and-upload-viewer-resources]

CHANGELOG.md

@@ -8,6 +8,11 @@ Changes can be:
 
 ## Unreleased
 
+* 🌟 Add compatibility with Babashka
+
+  Currently requires a dev build of Babashka ([6b89b78](https://github.com/babashka/babashka/commit/6b89b78c38e72d296f211e024d4079bf1504f3e4)
+  or newer).
+
 * 🕵🏻 New dependency analyzer implementation
 
    Based on the analyzer from [hyperfiddle/rfc](https://github.com/hyperfiddle/rcf). This replaces `tools.analyzer` and drops the dependency.

bb.edn

@@ -1,9 +1,7 @@
-{:min-bb-version "0.9.159"
+{:min-bb-version "1.12.202"
  :paths ["bb"]
- :deps {io.github.nextjournal/dejavu {:git/sha "4980e0cc18c9b09fb220874ace94ba6b57a749ca"}
-        io.github.nextjournal/cas-client {:git/sha "d9f838937ebc8b645fe5764949e72a6df8e344de"}
-        mvxcvi/multiformats {:git/url "https://github.com/greglook/clj-multiformats"
-                             :git/sha "1189f1fb26db180cd8dcfd50518cdf553c0ff9e1"}}
+ :deps {io.github.nextjournal/dejavu {:git/sha "7276cd9cec1bad001d595b52cee9e83a60d43bf0"}
+        io.github.nextjournal/cas-client {:git/sha "114d3d88d38a2068ec844b0e6c808eaaa6aa64ef"}}
  :tasks
  {:requires
   ([tasks :as t]
@@ -56,6 +54,22 @@
                                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}
+
+  dev:bb {:extra-deps {io.github.nextjournal/clerk {:local/root "."}}
+          :extra-paths ["notebooks" "resources" "test"]
+          :task (exec 'tasks/bb-nrepl)}
+
+  build:bb {:extra-deps {io.github.nextjournal/clerk {:local/root "."}}
+            :extra-paths ["notebooks" "resources" "test"]
+            :task (exec 'nextjournal.clerk/build!)}
+
   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

bb/tasks.clj

@@ -70,3 +70,14 @@
 
 (defn version []
   (shared/version))
+
+(defn bb-nrepl [args]
+  (System/setProperty "clerk.resource_manifest" (str {"/js/viewer.js" "/js/viewer.js"}))
+  ((requiring-resolve 'babashka.nrepl.server/start-server!) {:host "localhost" :port 1339})
+  (spit ".nrepl-port" "1339")
+  ((requiring-resolve 'nextjournal.clerk/serve!) args)
+  (-> (Runtime/getRuntime)
+      (.addShutdownHook (Thread. (fn []
+                                   ((requiring-resolve 'nextjournal.clerk/halt!))
+                                   (fs/delete ".nrepl-port")))))
+  (deref (promise)))

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.nextjournal/dejavu {:git/sha "7276cd9cec1bad001d595b52cee9e83a60d43bf0"}
         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"}
@@ -41,7 +42,7 @@
                               cider/cider-nrepl {:mvn/version "0.55.7"}
                               nrepl/nrepl {:mvn/version "1.3.1"}
                               com.clojure-goes-fast/clj-async-profiler {:mvn/version "1.3.0"}
-                              io.github.nextjournal/cas-client {:git/sha "d9f838937ebc8b645fe5764949e72a6df8e344de"}
+                              io.github.nextjournal/cas-client {:git/sha "114d3d88d38a2068ec844b0e6c808eaaa6aa64ef"}
                               org.slf4j/slf4j-nop {:mvn/version "2.0.7"}
                               org.babashka/cli {:mvn/version "0.5.40"}
                               org.clojure/data.int-map {:mvn/version "1.3.0"}}
@@ -93,7 +94,7 @@
                                 :nextjournal.garden/aliases [:demo]}
 
            :build {:deps {io.github.nextjournal/clerk {:local/root "."}
-                          io.github.nextjournal/cas-client {:git/sha "d9f838937ebc8b645fe5764949e72a6df8e344de"}
+                          io.github.nextjournal/cas-client {:git/sha "114d3d88d38a2068ec844b0e6c808eaaa6aa64ef"}
                           io.github.clojure/tools.build {:git/tag "v0.10.3" :git/sha "15ead66"}
                           io.github.slipset/deps-deploy {:git/sha "b4359c5d67ca002d9ed0c4b41b710d7e5a82e3bf"}}
                    :extra-paths ["bb" "src" "resources"] ;; for loading lookup-url in build

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,100 @@
 
 (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>"))
+(utils/if-bb
+ (defn ->AlwaysArrayMap [m]
+   (proxy [clojure.lang.APersistentMap clojure.lang.IMeta clojure.lang.IObj]
+       []
+     (valAt
+       ([k]
+        (get m k))
+       ([k default-value]
+        (get m k default-value)))
+     (iterator []
+       (.iterator ^java.lang.Iterable m))
+
+     (containsKey [k] (contains? m k))
+     (entryAt [k] (when (contains? m k)
+                    (get this k)))
+     (equiv [other] (= m other))
+     (empty [] (empty m))
+     (count [] (count m))
+     (assoc [k v] (if (< (count m) 8)
+                    (->AlwaysArrayMap (assoc m k v))
+                    (->AlwaysArrayMap (assoc-after m k v))))
+     (without [k] (->AlwaysArrayMap (dissoc m k)))
+     (seq [] (seq m))
+                                        ; a lot of map users expect meta to work
+     (meta [] (meta m))
+     (withMeta [meta] (->AlwaysArrayMap (with-meta m meta)))))
+
+ (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/when-not-bb
+ (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))