go-loop (clj)

(ns markright.ui
  (:require-macros [cljs.core.async.macros :refer [go go-loop]])
  (:require [om.next :as om :refer-macros [defui]]
            [om.dom :as dom :include-macros true]
            [goog.dom :as gdom]
            [markright.parser :as p]
            [electron.ipc :as ipc]
            [markright.components.codemirror :as cm]
            [markright.components.markdown :as md]
            [cljs.core.async :as async :refer [chan put! pub sub unsub <!]]))

                     ;; super mega hack
                     ;; FIXME: remove me
                     (go-loop []
                       (let [fx (<! p/root-channel)]
                         (fx this))
                       (recur))))
  (componentWillMount [this] (.setOptions js/marked #js {:gfm true}))
  (componentWillReceiveProps [this next-props])
  (render [this]
    (let [{:keys [app/text app/html app/force-overwrite app/filepath app/saved-text]} (om/props this)]
      (if (not (= 0 (.-length filepath)))
        (if (= text saved-text)
          (set! (.-title js/document) filepath)
          (set! (.-title js/document) (str "* " filepath))))

(ns clograms.fxs
  (:require [re-frame.core :as re-frame]
            [clograms.events :as events]
            [cljs.core.async :as async]
            [taoensso.sente  :as sente :refer [cb-success?]])
  (:require-macros [cljs.core.async.macros :as asyncm :refer [go-loop]]))

(re-frame/reg-fx
 :start-websocket
 (fn [{:keys [port]}]
   (println "Starting websocket on port " port)
   ;; Read from websocket
   (let [{:keys [chsk ch-recv send-fn state]} (sente/make-channel-socket-client! "/chsk"
                                                                                 nil
                                                                                 {:type :auto
                                                                                  :host "localhost"
                                                                                  :port port})] ; e/o #{:auto :ajax :ws}
     (go-loop [{:keys [?data]} (async/<! ch-recv)]
       (js/console.log "[WebSocket event]" ?data)
       (let [[ev dat] ?data]
         (case ev
           :updates/datoms (re-frame/dispatch [::events/new-datoms dat])
           nil))
       (recur (async/<! ch-recv)))
     (js/console.info "Websocket connection ready"))))

(ns datascript-chat.core
  (:require
    [cljs.core.async.macros :refer [go-loop]]))

(defmacro go-loop-sub [pub key binding & body]
 `(let [ch# (cljs.core.async/chan)]
    (cljs.core.async/sub ~pub ~key ch#)
    (go-loop []
      (let [~binding (cljs.core.async/<! ch#)]
        ~@body)
      (recur))))

(ns herfi.scene.macros
  (:require
    [cljs.core.async.macros :refer [go-loop]]
    [clojure.java.io :as io]
    [clojure.string :as str]))

(defmacro go-loop-sub [pub key binding & body]
  `(let [ch# (cljs.core.async/chan)]
     (herfi.common.communication/add-to-exit-ch ~key ch#)
     (cljs.core.async/sub ~pub ~key ch#)
     (go-loop []
       (let [~binding (cljs.core.async/<! ch#)]
         (when-not (= (first ~binding) :exit)
           (try
             ~@body
             (catch js/Error e
               (js/console.error "go-loop")
               (js/console.error e)))
           (recur))))))

(ns onyx-dashboard.components.main
  (:require [om.core :as om :include-macros true]
            [om-tools.dom :as dom :include-macros true]
            [om-tools.core :refer-macros [defcomponent]]
            [om-bootstrap.grid :as g]
            [om-bootstrap.random :as r]
            [onyx-dashboard.components.deployment :refer [select-deployment deployment-indicator 
                                                          deployment-time-travel deployment-peers deployment-log-dump]]
            [onyx-dashboard.components.jobs :refer [job-selector job-info job-management]]
            [onyx-dashboard.components.log :refer [log-entries-pager]]
            [onyx-dashboard.controllers.api :refer [api-controller]]
            [onyx-dashboard.state-query :as sq]
            [cljs.core.async :as async :refer [<! >! put! chan]])
  (:require-macros [cljs.core.async.macros :as asyncm :refer [go-loop]]))

(defcomponent main-component [{:keys [deployment metrics zk-up? enable-job-management] :as app} owner]
  (did-mount [_] 
             (let [api-ch (om/get-shared owner :api-ch)
                   chsk-send! (om/get-shared owner :chsk-send!)] 
               (go-loop []
                        (let [msg (<! api-ch)]
                          (om/transact! app (partial api-controller msg chsk-send!))
                          (recur)))))