Promising

dev_src/dev/core.cljs

@@ -3,13 +3,13 @@
             [clojure.core.async :as a :refer [<! >! chan close! put!]]
             [cognitect.transit :as t]
             [metosin.transit.dates :as d]
+            [promesa.core :as p]
             [dev.render :as render]
             [samak.runtime :as run]
             [samak.helpers :as helpers]
             [samak.builtins :as builtins])
   (:require-macros [cljs.core.async.macros :refer [go go-loop]]))
 
-
 (defn update-bar
   ""
   [a]
@@ -22,10 +22,14 @@
 
 (defn handle-update
   ""
-  [c]
+  [c done]
   (go-loop []
     (let [p (<! c)]
-      (update-bar p))
+      (do
+        (update-bar p)
+        (when (= p 100)
+          (println "done core")
+          (done))))
     (recur)))
 
 (defn handle-send
@@ -35,6 +39,7 @@
     (go-loop []
       (let [p (<! c)
             before (helpers/now)]
+        (println "to worker" p)
         (.postMessage worker (t/write w p))
         (render/trace ::render-out
                     (helpers/duration before (helpers/now))
@@ -44,28 +49,36 @@
 (def json-reader (t/reader :json {:handlers d/readers}))
 (defn make-handler
   ""
-  [load in]
+  [load to-main to-worker]
   (fn
     [event]
     (let [data (t/read json-reader (.-data event))]
+      (println "recv from w" data)
       (condp = (:target data)
         :load (put! load (:data data))
-        (put! in data)))))
+        :bootstrap (put! to-worker :init)
+        (put! to-main data)))))
+
 
 (defn init
   ""
   []
-  (println "start")
-  (let [in (chan)
-        out (chan)]
-    (render/start-render-runtime in out)
-    (let [w (js/Worker. "/js/oasis-worker.js")
+  (p/let [in-main (chan)
+          out-main (chan)
+          out-mult (a/mult out-main)
+          in-worker (chan)
+          in-preview (chan)
           loading (chan)]
-      (handle-update loading)
-      (aset w "onmessage" (make-handler loading in))
-      (handle-send w out)
-      ;; (.postMessage w (pr-str {:cmd "init" :args {:name "tl"}}))
-      )
+    (a/tap out-mult in-worker)
+    (render/start-render-runtime loading in-main out-main)
+    (let [w (js/Worker. "/js/oasis-worker.js")]
+      (handle-send w in-worker)
+      (aset w "onmessage" (make-handler loading in-main in-worker))
+      (handle-update loading
+                     (fn [] (p/do! ;; (a/tap out-mult in-preview)
+                                   ;; (render/start-preview-runtime in-preview in-main)
+                                   (render/start-main loading)
+                                   ))))
     ))
 
 (init)

dev_src/dev/render.cljc

@@ -5,48 +5,47 @@
      [clojure.string :as str]
      [clojure.edn :as edn]
      [clojure.core.async :as a :refer [<! >! chan go go-loop close! put! pipe]]
+     [promesa.core :as prom]
+     [samak.api :as api]
      [samak.helpers :as helpers]
-     [samak.lisparser :as p]
      [samak.builtins :as builtins]
      [samak.stdlib :as std]
      [samak.trace :as trace]
+     [samak.oasis :as oasis]
      [samak.caravan :as caravan]
+     [samak.lisparser :as p]
+     [samak.test-programs :as test-programs]
      [samak.pipes :as pipes]
-     [samak.runtime :as run]
-     [samak.runtime.stores :as stores])]
+     [samak.scheduler :as sched]
+     [samak.runtime :as run])]
    :cljs
    [(:require
      [clojure.string :as str]
      [cljs.reader :as edn]
      [clojure.core.async :as a :refer [<! >! chan close! put! pipe]]
+     [promesa.core :as prom]
+     [samak.api :as api]
      [samak.helpers :as helpers]
      [samak.lisparser :as p]
      [samak.ui_stdlib :as uistd]
      [samak.builtins :as builtins]
      [samak.stdlib :as std]
      [samak.trace :as trace]
+     [samak.oasis :as oasis]
      [samak.caravan :as caravan]
+     [samak.lisparser :as p]
+     [samak.test-programs :as test-programs]
      [samak.layout :as layout]
      [samak.pipes :as pipes]
-     [samak.runtime :as run]
-     [samak.runtime.stores :as stores])
+     [samak.scheduler :as sched]
+     [samak.runtime :as run])
     (:require-macros [cljs.core.async.macros :refer [go go-loop]])]))
 
 
-(defn make-piped
-  ""
-  [name]
-  {:target :pipe :named (keyword name)})
-
-(def std-mock-symbols
-  {'pipes/to-mouse (make-piped 'pipes/to-mouse)
-   'pipes/to-keyboard (make-piped 'pipes/to-keyboard)
-   'pipes/to-ui (make-piped 'pipes/to-ui)
-   'pipes/to-log (make-piped 'pipes/to-log)})
-
 (def renderer-symbols
   (merge builtins/samak-symbols
-         std-mock-symbols
+         std/pipe-symbols
+         caravan/symbols
          #?(:cljs layout/layout-symbols)
          #?(:cljs uistd/ui-symbols)))
 
@@ -55,77 +54,139 @@
                       :url "/api/v2/"}})
 (def tracer (atom {}))
 
+(def main-conf {:id "rt-main"
+                :modules {"oasis-core" {:depends {}
+                                        :sinks {:state (sched/make-pipe-id {:module :lone :type :sinks :name :state})}
+                                        :sources {
+                                                  :init (sched/make-pipe-id {:module :lone :type :sources :name :init})
+                                                  :kb (sched/make-pipe-id {:module :lone :type :sources :name :kb})
+                                                  :drag (sched/make-pipe-id {:module :lone :type :sources :name :drag})
+                                                  :hover (sched/make-pipe-id {:module :lone :type :sources :name :hover})
+                                                  :events (sched/make-pipe-id {:module :lone :type :sources :name :events})
+                                                  }
+                                        }}})
+
+
 (defn handle-update
   ""
   [msg pipe]
   (let [c (chan)]
     (a/tap (pipes/out-port pipe) c)
     (go-loop []
       (let [p (<! c)]
-        (println "render got" msg p))
+        (println msg p))
       (recur))))
 
-(def sched
-  (fn [broadcast]
+(def scheduler
+  (let [broadcast (pipes/pipe (chan) ::main-broadcast)
+        to-rt (pipes/pipe (chan) ::main-scheduler)]
     (println "sched")
-    (let [to-rt (pipes/pipe (chan))]
-      ;; (handle-update "out" broadcast)
-      ;; (handle-update "in" to-rt)
-      to-rt)))
+    ;; (handle-update "out" broadcast)
+    ;; (handle-update "in" to-rt)
+    (fn [] [to-rt broadcast])))
+
+(def scheduler2
+  (let [broadcast (pipes/pipe (chan) ::preview-broadcast)
+        to-rt (pipes/pipe (chan) ::preview-scheduler)]
+    (println "sched2")
+    (handle-update "out2" broadcast)
+    (handle-update "in2" to-rt)
+    (fn [] [to-rt broadcast])))
 
+(defn eval-test
+  ""
+  []
+  (let [code (str/join " " test-programs/tw)
+        parsed (p/parse-all code)]
+    (swap! rt #(reduce run/eval-expression! % (:value parsed)))
+    (run/fire-into-named-pipe @rt 'in "5" 0)))
+
+(defn run-oasis
+  ""
+  []
+  (prom/let [res (run/fire-into-named-pipe @rt 'oasis-init "1" 0)]
+    (println "oasis started: " res))
+  ;; (let [parsed [(api/defexp 'start (api/fn-call (api/symbol 'pipes/debug) []))]]
+  ;;   (doseq [expression parsed]
+  ;;     (caravan/repl-eval expression)))
+  )
 
 (defn get-named-pipe
-  [pipe-name event]
-  (let [pipe-symbol (symbol (name pipe-name))
-        pipe (run/get-definition-by-name @rt pipe-symbol)]
+  [rt pipe-name]
+  (let [mod-name (sched/module-id (:module pipe-name))
+        mod (run/resolve-fn rt mod-name)
+        pipe (get-in mod [(:type pipe-name) (:name pipe-name)])]
     (if (pipes/pipe? pipe)
       pipe
-      (println (str "could not find pipe " pipe-symbol)))))
+      (println "could not find pipe" mod-name "/" pipe-name "->" mod "/" pipe))))
 
 (def get-named-pipe-memo (memoize get-named-pipe))
 
 (defn handle-render
   ""
-  [c]
+  [rt c]
   (go-loop []
     (let [p (<! c)
           before (helpers/now)
           content (:samak.runtime/content p)]
-      ;; (println "render in paket" p)
+      (println (:id rt) "in paket" p)
       (when (= :samak.runtime/paket (:samak.runtime/type p))
-        (when-let [pipe (get-named-pipe-memo (:samak.runtime/target p))]
+        (when-let [pipe (get-named-pipe-memo rt (:samak.runtime/target p))]
           (pipes/fire-raw! pipe content))
         (trace/trace ::render-in
                      (helpers/duration before (helpers/now))
                      content)))
     (recur)))
 
-(def renderer
-  ["(def mod (modules/ui \"2\"))"
-   "(def ui ((-> mod :-sinks :-render) 42))"
-   "(| ((-> mod :-sources :-events) 42) (pipes/to-ui))"
-   "(| ((-> mod :-sources :-mouse) 42) (pipes/to-mouse))"
-   "(| ((-> mod :-sources :-keyboard) 42) (pipes/to-keyboard))"])
-
-(defn eval-render
-  ""
-  []
-  (let [code (str/join " " renderer)
-        parsed (p/parse-all code)]
-    (swap! rt #(reduce run/eval-expression! % (:value parsed)))))
-
 (defn trace
   [src duration msg]
   (trace/trace src duration msg))
 
+(defn start-oasis
+  ""
+  [load]
+  (println "loading oasis")
+  (prom/let [net (sched/load-bundle @rt 'oasis)]
+    (helpers/debounce
+      (fn []
+        (prom/do!
+         (println "evaluating oasis")
+         (sched/eval-module rt main-conf net nil)
+         (println "renderer loaded oasis")
+         (helpers/debounce run-oasis))))))
+
+(defn start-main
+  ""
+  [load]
+  (println "start-main")
+  (helpers/debounce #(start-oasis load)))
+
+(defn start-preview-runtime
+  ""
+  [in-c out-c]
+  (println "renderer starting preview")
+  (let [[to-rt to-out] (scheduler2)
+        in-mult (a/mult in-c)
+        rt-c (chan)
+        paket-c (chan)]
+    (a/tap in-mult rt-c)
+    (pipes/link! to-out (pipes/sink out-c))
+    (pipes/link! (pipes/source rt-c) to-rt)
+    (prom/let [rt-inst (run/make-runtime renderer-symbols scheduler2 {:store :remote :id "rt-preview"})
+               rt-atom (atom rt-inst)]
+      ;; (a/tap in-mult paket-c)
+      ;; (handle-render rt-atom paket-c)
+      (println "renderer started preview"))))
+
 (defn start-render-runtime
   ""
-  [in out]
-  (reset! rt (run/make-runtime renderer-symbols sched))
-  (reset! tracer (trace/init-tracer @rt (:tracer config)))
-  (println "renderer started runtime" (:id @rt))
-  (eval-render)
-  (pipes/link! (:broadcast @rt) (pipes/sink out))
-  ;; (pipes/link! (pipes/source in) (:scheduler @rt))
-  (handle-render in)
-  )
+  [load in out]
+  (prom/let [rt-inst (run/make-runtime renderer-symbols scheduler main-conf)]
+    (reset! rt rt-inst)
+    (println "persisting oasis")
+    (oasis/store (:store @rt))
+    (println "persist done")
+    (pipes/link! (:broadcast @rt) (pipes/sink out))
+    (pipes/link! (pipes/source in) (:scheduler @rt))
+    (reset! tracer (trace/init-tracer @rt (:tracer config)))
+    (println "renderer started runtime" (:id @rt))))

dev_src/dev/worker.cljs

@@ -24,6 +24,7 @@
     (go-loop []
       (let [p (<! c)
             before (helpers/now)]
+        ;; (println "to main" p)
         (.postMessage js/self (t/write w p))
         (worker/trace ::worker-out
                     (helpers/duration before (helpers/now))
@@ -33,12 +34,15 @@
 (def json-reader (t/reader :json {:handlers d/readers}))
 (defn make-handler
   ""
-  [in]
+  [in init]
   (fn
     [event]
     (let [before (helpers/now)
           data (t/read json-reader (.-data event))]
-      (put! in data)
+      ;; (println "worker in" data)
+      (if (= data :init)
+        (helpers/debounce init)
+        (put! in data))
       (worker/trace ::worker-in
                     (helpers/duration before (helpers/now))
                     (:samak.runtime/content data)))))
@@ -52,7 +56,8 @@
         out (chan)]
     (handle-update loading)
     (handle-request out)
-    (worker/start-rt loading in out)
-    (aset js/self "onmessage" (make-handler in))))
+    (aset js/self "onmessage" (make-handler in #(worker/start-rt loading in out)))
+    (put! out {:target :bootstrap})
+    ))
 
 (bootstrap)

project.clj

@@ -28,6 +28,7 @@
                  [ring/ring-defaults "0.3.2"]
                  [derekchiang/ring-proxy "1.0.1"]
                  [camel-snake-kebab "0.4.0"]
+                 [funcool/promesa "6.0.0"]
                  [keybind "2.1.0"]
                  [expound "0.7.2"]
                  [org.clojure/test.check "0.9.0"]]

resources/public/index_oasis.html

@@ -10,7 +10,7 @@
     <script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.4.0/react-dom.js"></script>
   </head>
   <body style="background-color:black" oncontextmenu="return false;">
-    <div id="samak"></div>
+    <div id="samak1" class="preview"></div>
     <div id="samak2" class="fullscreen">
       <div class="center">
         <div class="center bar-bg">

src/samak/api.cljc

@@ -20,6 +20,10 @@
   #:samak.nodes{:type :samak.nodes/fn-ref
                 :fn   [:samak.nodes/name identifier]})
 
+(defn id-ref [identifier]
+  #:samak.nodes{:type :samak.nodes/fn-ref
+                :fn   {:db/id identifier}})
+
 (defn pipe
   ([from to]
    #:samak.nodes {:type :samak.nodes/pipe