wip

src/babashka/pods/jvm.clj

@@ -1,6 +1,38 @@
 (ns babashka.pods.jvm
   (:require [babashka.pods.impl :as impl]))
 
+(def ^:private namespaces-to-load (atom {}))
+
+(defn- unroot-resource [^String path]
+  (symbol (.. path
+              (substring 1)
+              (replace \/ \. )
+              (replace \_ \-))))
+
+(defn- process-namespace [{:keys [:name :vars :done]}]
+  (binding [*ns* (load-string (format "(ns %s) *ns*" name))]
+    (doseq [[var-sym v] vars]
+      (cond
+        (ifn? v)
+        (do
+          (ns-unmap *ns* var-sym)
+          (intern name var-sym v))
+        (string? v)
+        (load-string v))))
+  (when done (deliver done :ok)))
+
+(let [core-load clojure.core/load]
+  (intern 'clojure.core 'load
+          (fn [& paths]
+            (let [nss @namespaces-to-load]
+              (doseq [path paths]
+                (let [lib (unroot-resource path)]
+                  (if-let [pod (get nss lib)]
+                    (impl/load-ns
+                     pod lib (fn [namespace]
+                               (process-namespace namespace)))
+                    (core-load path))))))))
+
 (defn load-pod
   ([pod-spec] (load-pod pod-spec nil))
   ([pod-spec _opts]
@@ -12,17 +44,20 @@
                               (intern
                                (create-ns (symbol (namespace sym)))
                                (symbol (name sym)))))})
-         namespaces (:namespaces pod)]
+         namespaces (:namespaces pod)
-     (doseq [[ns-sym v] namespaces]
+         load? (contains? (:ops pod) :load)]
-       (binding [*ns* (load-string (format "(ns %s) *ns*" ns-sym))]
+     (when load?
-         (doseq [[var-sym v] v]
+       (swap! namespaces-to-load
-           (cond
+              merge
-             (ifn? v)
+              (into {}
-             (do
+                    (keep (fn [[ns-name vars]]
-               (ns-unmap *ns* var-sym)
+                            (when (empty? vars)
-               (intern ns-sym var-sym v))
+                              [ns-name pod]))
-             (string? v)
+                          namespaces))))
-             (load-string v)))))
+     (doseq [[ns-sym vars] namespaces
+             :when (or (not load)
+                       (seq vars))]
+       (process-namespace {:name ns-sym :vars vars}))
      (future (impl/processor pod))
      {:pod/id (:pod-id pod)})))
 

test-resources/test_program.clj

@@ -47,7 +47,6 @@
 (def other-tagged (pod/other-tag))
 
 (require '[pod.test-pod.loaded])
-
 (def loaded (pod.test-pod.loaded/loaded 1))
 
 (pods/unload-pod pod-id)