wip

src/babashka/pods/impl.clj

@@ -30,6 +30,9 @@
   (some-> (get m k)
           bytes->string))
 
+(def callbacks
+  (atom {}))
+
 (defn processor [pod]
   (let [stdout (:stdout pod)
         format (:format pod)
@@ -47,8 +50,11 @@
                            ::EOF))]
           (when-not (identical? ::EOF reply)
             (let [id (get reply "id")
-                  id    (bytes->string id)
+                  id    (bytes->string id)]
-                  value* (find reply "value")
+              (if-let [cb (get @callbacks id)]
+                (do (swap! callbacks dissoc id)
+                    (cb reply))
+                (let [value* (find reply "value")
                       value (some-> value*
                                     second
                                     bytes->string
@@ -98,7 +104,7 @@
                     (binding [*out* out-stream]
                       (println out)))
                   (when err (binding [*out* err-stream]
-                          (println err))))
+                              (println err))))))
             (recur))))
       (catch Exception e
         (binding [*out* *err* #_err-stream]
@@ -161,6 +167,30 @@
           dict-vals (map (comp resolve-fn bytes->symbol) (vals dict))]
       (zipmap dict-keys dict-vals))))
 
+(defn bencode->vars [pod ns-name-str vars]
+  (mapv
+   (fn [var]
+     (let [name (get-string var "name")
+           async? (some-> (get var "async")
+                          bytes->string
+                          #(Boolean/parseBoolean %))
+           name-sym (symbol name)
+           sym (symbol ns-name-str name)
+           code (get-maybe-string var "code")]
+       [name-sym
+        (or code
+            (fn [& args]
+              (let [res (invoke pod sym args {:async async?})]
+                res)))]))
+   vars))
+
+(defn bencode->namespace [pod namespace]
+  (let [name-str (-> namespace (get "name") bytes->string)
+        name-sym (symbol name-str)
+        vars (get namespace "vars")
+        vars (bencode->vars pod name-str vars)]
+    [name-sym vars]))
+
 (defn load-pod
   ([pod-spec] (load-pod pod-spec nil))
   ([pod-spec {:keys [:remove-ns :resolve]}]
@@ -197,33 +227,23 @@
                       (get-string ns "name"))
                     (next-id))
          pod (assoc pod :pod-id pod-id)
-         vars-fn (fn [ns-name-str vars]
+         pod-namespaces (mapv #(bencode->namespace pod %)
-                   (mapv
-                    (fn [var]
-                      (let [name (get-string var "name")
-                            async? (some-> (get var "async")
-                                           bytes->string
-                                           #(Boolean/parseBoolean %))
-                            name-sym (symbol name)
-                            sym (symbol ns-name-str name)
-                            code (get-maybe-string var "code")]
-                        [name-sym
-                         (or code
-                             (fn [& args]
-                               (let [res (invoke pod sym args {:async async?})]
-                                 res)))]))
-                    vars))
-         pod-namespaces (mapv (fn [namespace]
-                                (let [name-str (-> namespace (get "name") bytes->string)
-                                      name-sym (symbol name-str)
-                                      vars (get namespace "vars")
-                                      vars (vars-fn name-str vars)]
-                                  [name-sym vars]))
                               pod-namespaces)
          pod (assoc pod :namespaces pod-namespaces)]
      (swap! pods assoc pod-id pod)
      pod)))
 
+(defn load-ns [pod namespace callback]
+  (let [id (next-id)
+        callback (fn [reply]
+                   (let [namespace (bencode->namespace pod reply)]
+                     (callback namespace)))]
+    (swap! callbacks assoc id callback)
+    (write (:stdin pod)
+           {"op" "load"
+            "path" (str namespace)
+            "id" id})))
+
 (defn invoke-public [pod-id fn-sym args opts]
   (let [pod (lookup-pod pod-id)]
     (invoke pod fn-sym args opts)))

src/babashka/pods/sci.clj

@@ -47,7 +47,8 @@
          (when (seq namespaces-to-load)
            (let [load-fn (fn load-fn [{:keys [:namespace]}]
                            (when (contains? namespaces-to-load namespace)
-                             #_(impl/load pod namespace (fn [namespace]
+                             (impl/load-ns
+                              pod namespace (fn [namespace]
                                               (process-namespace ctx namespace)))
                              ""))
                  prev-load-fn (:load-fn @env)