Primitive support for customize *context*

This commit add options to customize
- *customize-builder* :: to customize the default ContextBuilder
- *after-init-hook* :: called after a context is created

More importantly, primitive support for automatically creating and
using thread local context. Check *context-per-thread*.

Author: imakira

src/net/coruscation/js4clj/context.clj

@@ -4,8 +4,9 @@
    [org.graalvm.polyglot Context])
   (:require [clojure.java.io :as io]))
 
-(defonce ^{:dynamic true :private true} *cjs-cwd* (str (System/getProperty "user.dir")
-                                                       "/node_modules"))
+(defonce ^{:dynamic true :private true} *cjs-cwd*
+  (str (System/getProperty "user.dir")
+       "/node_modules"))
 
 (defn default-builder
   "Return a `org.graalvm.polyglot.Context$Builder` object with necessary options set for js4clj to function properly.
@@ -31,26 +32,69 @@
                   "js.commonjs-require-cwd" *cjs-cwd*}))
       (.allowIO true)))
 
-(defonce ^{:dynamic true
-           :doc "An atom wrapping a instance of `org.graalvm.polyglot.Context$Builder`, used for all the operations "}
-  *context* (atom (.build (default-builder))))
+(def ^:dynamic *context-per-thread*
+  "Whether to use thread local context when doing js4clj operations."
+  false)
 
-(defn initialize-context!
-  "Initialize the `*context*` variable with a lambda taking `default-builder` as an argument.
+(def ^:dynamic *customize-builder*
+  "A fn takes a `Context$Builder` as an argument and returns a `Context$Builder`"
+  nil)
 
-  `defaut-builder` is an `org.graalvm.polyglot.Context$Builder` object with necessary option set for js4clj to function properly.
-  The lambda should return a `org.graalvm.polyglot.Context` object to initialize the *context* variable.
+(def ^:private builtin-after-init
+  (fn [ctx]
+    (.eval ctx "js" "globalThis.global = this")
+    (.eval ctx "js" "globalThis.process = {}")
+    (.eval ctx "js" "globalThis.process.env = {}")))
 
-  Example:
-  ```clojure
-  (initialize-context! (fn [builder]
-    (.build builder)))
-  ```
-  "
-  [build-fn]
-  (let [default-builder (default-builder)]
-    (reset! *context* (build-fn default-builder))))
+(def ^:dynamic *after-init-hook*
+  "A fn takes no arguments, called after a context is created, with *context* bound to the newly created context."
+  nil)
+
+(declare *context*)
+
+(defn context-new
+  "Create a context, respect `customize-builder` and `after-init-hook`"
+  []
+  (let [context (-> (default-builder)
+                    (or *customize-builder* identity)
+                    (.build))]
+    (when builtin-after-init (builtin-after-init context))
+    (when *after-init-hook*
+      (binding [*context* (ref context)]
+        (*after-init-hook*)))
+    context))
+
+(def ^:private global-context (atom nil))
 
-(.eval @*context* "js" "globalThis.global = this")
-(.eval @*context* "js" "globalThis.process = {}")
-(.eval @*context* "js" "globalThis.process.env = {}")
+(def ^:private thread-local-context (ThreadLocal/withInitial (fn [] (context-new))))
+
+(def ^{:dynamic true
+       :doc
+       "When `*context-per-thread*` is false, deref it returns the global context,
+        When `*context-per-thread*` is true, deref it returns the thread local context.
+
+	    In any case, if it is not already initialized, initialize it with `context-new`
+
+	    You can bind it with an IDeref instance to manage context."}
+  *context* (reify clojure.lang.IDeref
+              (deref [_]
+                (if *context-per-thread*
+                  (.get thread-local-context)
+                  (if (not (nil? @global-context))
+                    @global-context
+                    (swap! global-context
+                           (fn [old]
+                             (if old
+                               old
+                               (context-new)))))))))
+
+(defn reinitialize-context!
+  "If `*context-per-thread*` is false, reinitialize the global `*context*` with `context-new`.
+  If `*context-per-thread*` is true, reinitialize the thread-local context with `context-new`.
+
+  Note: Contexts are automatically initialize upon first usage  if not already initialized.
+  "
+  []
+  (if *context-per-thread*
+    (.set thread-local-context (context-new))
+    (reset! global-context (context-new))))

src/net/coruscation/js4clj/core.clj

@@ -26,3 +26,5 @@
 
   Example (js-new js/Array 1 2 3) => [1 2 3]"
   (apply new-instance obj (map polyglotalize-clojure args)))
+
+

test/net/coruscation/js4clj/context_test.clj

@@ -0,0 +1,48 @@
+(ns net.coruscation.js4clj.context-test
+  (:require
+   [clojure.test :refer [deftest is use-fixtures]]
+   [net.coruscation.js4clj.context :as subject]
+   [net.coruscation.js4clj.js :as js]
+   [net.coruscation.js4clj.test-utils :refer [fresh-context]]
+   [net.coruscation.js4clj.utils :refer [js-set! js.-]]))
+
+(deftest *context-per-thread*-test
+  (binding [subject/*context-per-thread* true]
+    (.eval @subject/*context*
+           "js"
+           "globalThis.demo = 1")
+    (let [thread (Thread/new
+                  (bound-fn []
+                    (is (nil? (js.- js/globalThis
+                                    demo)))))]
+      (.start thread)
+      (is (= 1
+             (js.- js/globalThis
+                   demo)))
+      (.join thread
+             200))))
+
+(deftest *after-init-hook*-test
+  (binding [subject/*after-init-hook*
+            (fn []
+              (js-set! (js.- js/globalThis
+                             demo)
+                       2))]
+    (subject/reinitialize-context!)
+    (is (= 2 (js.- js/globalThis
+                   demo)))))
+
+(deftest reinitialize-context!-test
+  (is (nil? (js.- js/globalThis
+                  demo)))
+  (js-set! (js.- js/globalThis
+                 demo)
+           2)
+  (is (= 2
+         (js.- js/globalThis
+               demo)))
+  (subject/reinitialize-context!)
+  (is (nil? (js.- js/globalThis
+                  demo))))
+
+(use-fixtures :each #'fresh-context)

test/net/coruscation/js4clj/test_utils.clj

@@ -0,0 +1,8 @@
+(ns net.coruscation.js4clj.test-utils
+  (:require
+   [clojure.test :refer :all]
+   [net.coruscation.js4clj.context :as context]))
+
+(defn fresh-context [test]
+  (context/reinitialize-context!)
+  (test))