feat: [#23] Lazy loading of occasionally needed code (#27)

Author: borkdude

.github/workflows/ci.yml

@@ -18,7 +18,12 @@ jobs:
       - name: Setup Babashka
         uses: turtlequeue/[email protected]
         with:
-          babashka-version: 0.7.0
+          babashka-version: 0.7.3
+
+      - name: Register bb clojure as clojure command
+        run: |
+          echo -e '#!/usr/bin/env bash\n\nbb --clojure "$@"' > /usr/local/bin/clojure
+          chmod +x /usr/local/bin/clojure
 
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v2

bb.edn

@@ -5,18 +5,19 @@
           :sha     "a83ee8da47d56a80b6380cbb6b4b9274048067bd"}}
 
  :tasks {:requires [[babashka.fs :as fs]
+                    [clojure.string :as str]
                     [clojure.edn :as edn]]
 
-         :init (do (def target-dir "out")
+         :init (do (def target-dir (fs/absolutize "out"))
                    (def executable-name "obb")
                    (def bin-dir (str (fs/file target-dir "bin")))
+                   (def main-js (str (fs/file target-dir "obb.js")))
                    (def executable-path (str (fs/file bin-dir executable-name)))
-                   (def version (:version (edn/read-string (slurp "project.edn")))))
+                   (def version (:version (edn/read-string (slurp "project.edn"))))
+                   (def tar-file (fs/file target-dir "obb.tar.gz")))
 
          clean (fs/delete-tree target-dir)
 
-         compile (clojure "-M -m cljs.main -co build.edn -c")
-
          shadow-server (do
                          (shell "npm install")
                          (shell "npx shadow-cljs server"))
@@ -25,23 +26,33 @@
 
          dev (load-file "bb/watch.clj")
 
-         build (when (seq (fs/modified-since executable-path ["deps.edn" "src"]))
-                 (run 'compile)
-                 (let []
-                   (fs/create-dirs bin-dir)
-                   (spit executable-path
-                         (str "#!/usr/bin/env osascript -l JavaScript\n\n"
-                              (slurp "out/main.js")))
-                   (shell (str "chmod u+x " executable-path))))
+         shadow-release (shell "npx shadow-cljs release obb"
+                               "--config-merge"
+                               "{:compiler-options {:optimizations :advanced}}")
+
+         build (when (seq (fs/modified-since executable-path ["deps.edn"
+                                                              "shadow-cljs.edn"
+                                                              "src"]))
+                 (println "Compiling obb")
+                 (run 'shadow-release)
+                 (fs/create-dirs bin-dir)
+                 (println "Preparing executable")
+                 (spit executable-path
+                       (str "#!/usr/bin/env osascript -l JavaScript\n\n"
+                            (slurp "out/obb.js")))
+                 (shell (str "chmod u+x " executable-path)))
+
+         tar {:depends [build]
+              :requires ([tar])
+              :task (tar/tar {:executable-path executable-path
+                              :executable-name executable-name
+                              :tar-file tar-file})}
 
          upload-assets  {:doc    "Uploads jar and vsix to Github"
-                         :depends [build]
+                         :depends [tar]
                          :requires ([upload-release :as ur])
-                         :task    (do
-                                    (fs/copy executable-path ".")
-                                    (shell "tar -czvf" "obb.tar.gz" executable-name)
-                                    (ur/release {:file "obb.tar.gz"
-                                                 :version version}))}
+                         :task    (ur/release {:file tar-file
+                                               :version version})}
 
          test {:doc "Run integration tests"
                :depends [build]

bb/tar.clj

@@ -0,0 +1,20 @@
+(ns tar
+  (:require [babashka.fs :as fs]
+            [babashka.tasks :refer [shell]]))
+
+(defn tar [{:keys [executable-name
+                   executable-path
+                   tar-file]}]
+  (fs/with-temp-dir [tmp-dir {}]
+    (fs/copy executable-path tmp-dir)
+    (fs/copy "script/brew_install.sh" tmp-dir)
+    (let [libexec (fs/file tmp-dir "libexec")]
+      (fs/create-dirs libexec)
+      (run! (fn [js-file]
+              (when-not (contains? #{"obb.js" "inferred_externs.js"}
+                                   (fs/file-name js-file))
+                (fs/copy js-file (fs/file libexec (fs/file-name js-file)))))
+            (fs/glob "out" "*.js"))
+      (shell {:dir (str tmp-dir)}
+             "tar -czvf" "obb.tar.gz" executable-name "brew_install.sh" "libexec")
+      (fs/copy (fs/file tmp-dir "obb.tar.gz") tar-file {:replace-existing true}))))

build.edn

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+prefix="$1"
+
+# obb executable
+mkdir -p "$prefix/bin"
+echo 'globalThis.obb_brew = true;' >> obb
+echo "globalThis.obb_lib_dir = \"$prefix/libexec\";" >> obb
+cp obb "$prefix/bin"
+
+# internal libs
+mkdir -p "$prefix/libexec"
+cp libexec/* "$prefix/libexec"
+
+mkdir -p "$prefix/bin"
+cp obb "$prefix/bin"

script/brew_install.sh

@@ -1,6 +1,9 @@
 {:deps {:aliases [:dev]}
  :builds {:obb {:target :browser
-                :modules {:obb {:entries [obb.main]}}
+                :modules {:obb {:entries [obb.main]}
+                          :obb_repl {:entries [obb.impl.repl]
+                                     :depends-on #{:obb}}}
                 :output-dir "out"
                 :release {:compiler-options {:optimizations :simple}}}}
+ ;; used for detecting when server is finished loading
  :nrepl {:port 13337}}

shadow-cljs.edn

@@ -0,0 +1,95 @@
+(ns obb.impl.core
+  (:refer-clojure :exclude [prn slurp])
+  (:require [clojure.core :as clojure]
+            [obb.impl.sci :as impl.sci]
+            [sci.core :as sci]
+            [sci.impl.interop :as interop]))
+
+(def app
+  (delay (let [app (js/Application.currentApplication)]
+           (set! (.-includeStandardAdditions app) true)
+           app)))
+
+(set! (.-obb_lib_dir js/globalThis) "out")
+
+(defn prefix []
+  (.-obb_lib_dir js/globalThis))
+
+(defn slurp
+  "Like `clojure.core/slurp` but only accepts paths."
+  [x]
+  (.read @app (js/Path x #js {})))
+
+(defn load-fn [{:keys [namespace]}]
+  (case namespace
+    obb.repl (let [code (slurp (str (prefix) "/obb_repl.js"))]
+               ;; @zane: there might be a better way to evaluate in osascript JS
+               (js/eval code)
+               {:source ""})))
+
+(defn display-string
+  "Returns the JXA display string for an object specifier."
+  [os]
+  (js/Automation.getDisplayString os))
+
+(defn object-specifier?
+  "Returns true if x is an object specifier."
+  [x]
+  (js/ObjectSpecifier.hasInstance x))
+
+(defn not-object-specifier-pred-1 [f]
+  (fn [x]
+    (when-not (object-specifier? x)
+      (f x))))
+
+(defn not-object-specifier-pred-2 [f]
+  (fn [x y]
+    (when-not (object-specifier? x)
+      (f x y))))
+
+(set! interop/invoke-instance-method impl.sci/invoke-instance-method)
+
+(set! interop/invoke-static-method impl.sci/invoke-static-method)
+
+(set! clojure/map? (not-object-specifier-pred-1 map?))
+
+(set! clojure/meta (not-object-specifier-pred-1 meta))
+
+(enable-console-print!)
+
+(sci/alter-var-root sci/print-fn (constantly *print-fn*))
+
+(def print*
+  ;; All output from osascript by default goes to stderr. To get around this
+  ;; we use the Objective-C bridge to write directly to stdout.
+
+  ;; `delay` ensures that this import happens only when needed, and only once.
+  (let [import (delay (.import js/ObjC "Foundation"))]
+    (fn [s]
+      @import
+      (-> (.dataUsingEncoding (js/ObjC.wrap s) js/$.NSUTF8StringEncoding)
+          (js/$.NSFileHandle.fileHandleWithStandardOutput.writeData)))))
+
+(defn prn
+  "Like `clojure.core/prn`, but will not crash if called on an object specifier.
+  Object specifiers are printed as their display string with the prefix
+  #org.babashka.obb/object-specifier."
+  [x]
+  (let [object-specifier-tag "#org.babashka.obb/object-specifier"]
+    (print*
+     (if (object-specifier? x)
+       (str object-specifier-tag " " (pr-str (display-string x)))
+       (pr-str x))))
+  (print* \newline))
+
+(def ctx (atom (sci/init {:load-fn load-fn
+                          :classes {'js goog/global
+                                    :allow :all}})))
+
+(defn eval-string
+  "Evaluates a string using `ctx` as the context."
+  [s]
+  (sci/eval-string* @ctx s))
+
+(defn register-plugin! [_plug-in-name sci-opts]
+  (swap! ctx sci/merge-opts sci-opts))

src/obb/impl/core.cljs

@@ -1,98 +1,26 @@
 (ns obb.impl.main
-  (:refer-clojure :exclude [prn slurp])
-  (:require [clojure.core :as clojure]
-            [clojure.tools.cli :as cli]
-            [obb.impl.sci :as impl.sci]
-            [sci.core :as sci]
-            [sci.impl.interop :as interop]))
+  (:require [clojure.tools.cli :as cli]
+            [obb.impl.core :as impl.core :refer [slurp ctx prefix]]))
 
 (def cli-options
   [["-e" "--eval <expr>"]])
 
-(def app
-  (delay (let [app (js/Application.currentApplication)]
-           (set! (.-includeStandardAdditions app) true)
-           app)))
-
-(defn slurp
-  "Like `clojure.core/slurp` but only accepts paths."
-  [x]
-  (.read @app (js/Path x #js {})))
-
-(defn display-string
-  "Returns the JXA display string for an object specifier."
-  [os]
-  (js/Automation.getDisplayString os))
-
-(defn object-specifier?
-  "Returns true if x is an object specifier."
-  [x]
-  (js/ObjectSpecifier.hasInstance x))
-
-(defn not-object-specifier-pred-1 [f]
-  (fn [x]
-    (when-not (object-specifier? x)
-      (f x))))
-
-(defn not-object-specifier-pred-2 [f]
-  (fn [x y]
-    (when-not (object-specifier? x)
-      (f x y))))
-
-(set! interop/invoke-instance-method impl.sci/invoke-instance-method)
-
-(set! interop/invoke-static-method impl.sci/invoke-static-method)
-
-(set! clojure/map? (not-object-specifier-pred-1 map?))
-
-(set! clojure/meta (not-object-specifier-pred-1 meta))
-
-(enable-console-print!)
-
-(sci/alter-var-root sci/print-fn (constantly *print-fn*))
-
-(def ctx (sci/init {:classes {'js goog/global
-                              :allow :all}}))
-
-(defn eval-string
-  "Evaluates a string using `ctx` as the context."
-  [s]
-  (sci/eval-string* ctx s))
-
-(def print*
-  ;; All output from osascript by default goes to stderr. To get around this
-  ;; we use the Objective-C bridge to write directly to stdout.
-
-  ;; `delay` ensures that this import happens only when needed, and only once.
-  (let [import (delay (.import js/ObjC "Foundation"))]
-    (fn [s]
-      @import
-      (-> (.dataUsingEncoding (js/ObjC.wrap s) js/$.NSUTF8StringEncoding)
-          (js/$.NSFileHandle.fileHandleWithStandardOutput.writeData)))))
-
-(defn prn
-  "Like `clojure.core/prn`, but will not crash if called on an object specifier.
-  Object specifiers are printed as their display string with the prefix
-  #org.babashka.obb/object-specifier."
-  [x]
-  (let [object-specifier-tag "#org.babashka.obb/object-specifier"]
-    (print*
-     (if (object-specifier? x)
-       (str object-specifier-tag " " (pr-str (display-string x)))
-       (pr-str x))))
-  (print* \newline))
-
 (defn main [argv]
   (let [args (js->clj argv)
         {:keys [arguments summary] {form :eval} :options} (cli/parse-opts args cli-options)]
     (cond (some? form)
-          (prn (eval-string form))
+          (impl.core/prn (impl.core/eval-string form))
 
           (and (seq arguments)
                (= 1 (count arguments)))
           (let [form (slurp (first arguments))]
-            (eval-string form))
+            (impl.core/eval-string form))
 
           :else
-          (println summary))
+          (let [src (slurp (str (prefix) "/obb_repl.js"))]
+            (js/eval src)
+            (let [env @(:env @ctx)
+                  foo (get-in env [:namespaces 'obb.repl 'foo])]
+              (foo) ;; TODO: launch REPL instead of printing summary
+              (println summary))))
     js/undefined)) ; suppress printing of return value

src/obb/impl/main.cljs

@@ -0,0 +1,13 @@
+(ns obb.impl.repl
+  (:require [obb.impl.core :as impl.core]
+            [sci.core :as sci]))
+
+(defn foo []
+  ;; TODO: launch REPL
+  )
+
+(impl.core/register-plugin!
+ ::repl
+ {:namespaces
+  {'obb.repl {'foo (sci/copy-var foo
+                                 (sci/create-ns 'obb.repl nil))}}})