Merge pull request #231 from tanzoniteblack/ryan/core-async-1.6.673

Upgrade to core.async 1.6.673

Author: KingMob

.circleci/config.yml

@@ -40,3 +40,4 @@ jobs:
 
       # run tests!
       - run: lein do clean, test
+      - run: lein with-profile +older-core-async do clean, test manifold.go-off-test

project.clj

@@ -8,9 +8,12 @@
                  [org.clojure/tools.logging "1.2.4" :exclusions [org.clojure/clojure]]
                  [org.clj-commons/dirigiste "1.0.3"]
                  [riddley "0.2.0"]
-                 [org.clojure/core.async "1.5.648" :scope "provided"]
+                 [org.clojure/core.async "1.6.673" :scope "provided"]
                  [potemkin "0.4.6"]]
-  :profiles {:dev {:dependencies [[criterium "0.4.6"]]}}
+  :profiles {:dev {:dependencies [[criterium "0.4.6"]]}
+             ;; core.async moved around some internal functions go-off relies on; this profile
+             ;; helps test that go-off still works both with the new namespaces and the old
+             :older-core-async {:dependencies [[org.clojure/core.async "1.5.648" :scope "provided"]]}}
   :test-selectors {:default #(not
                                (some #{:benchmark :stress}
                                  (cons (:tag %) (keys %))))

src/manifold/go_off.clj

@@ -10,8 +10,14 @@
             [manifold.stream :as s])
   (:import (manifold.stream.core IEventSource)))
 
+;; a number of functions from `ioc-macros` moved to `runtime` in org.clojure/core.async "1.6.673"
+;; since they were just moved without functionality changes, continue to support both via dynamic import
+(if (find-ns 'clojure.core.async.impl.runtime)
+  (require '[clojure.core.async.impl.runtime :as async-runtime])
+  (require '[clojure.core.async.impl.ioc-macros :as async-runtime]))
+
 (defn ^:no-doc return-deferred [state value]
-  (let [d (ioc/aget-object state ioc/USER-START-IDX)]
+  (let [d (async-runtime/aget-object state async-runtime/USER-START-IDX)]
     (d/success! d value)
     d))
 
@@ -38,28 +44,28 @@
        r#)))
 
 (defn ^:no-doc run-state-machine-wrapped [state]
-  (try (ioc/run-state-machine state)
+  (try (async-runtime/run-state-machine state)
        (catch Throwable ex
-         (d/error! (ioc/aget-object state ioc/USER-START-IDX) ex)
+         (d/error! (async-runtime/aget-object state async-runtime/USER-START-IDX) ex)
          (throw ex))))
 
 (defn ^:no-doc take! [state blk d]
   (let [handler          (fn [x]
-                           (ioc/aset-all! state ioc/VALUE-IDX x ioc/STATE-IDX blk)
+                           (async-runtime/aset-all! state async-runtime/VALUE-IDX x async-runtime/STATE-IDX blk)
                            (run-state-machine-wrapped state))
         ;; if `d` is a stream, use `take` to get a deferrable that we can wait on
         d                (if (instance? IEventSource d) (s/take! d) d)
         d-is-deferrable? (d/deferrable? d)]
     (if
       ;; if d is not deferrable immediately resume processing state machine
       (not d-is-deferrable?)
-      (do (ioc/aset-all! state ioc/VALUE-IDX d ioc/STATE-IDX blk)
+      (do (async-runtime/aset-all! state async-runtime/VALUE-IDX d async-runtime/STATE-IDX blk)
           :recur)
       (let [d (d/->deferred d)]
         (if
           ;; if already realized, deref value and immediately resume processing state machine
           (d/realized? d)
-          (do (ioc/aset-all! state ioc/VALUE-IDX @d ioc/STATE-IDX blk)
+          (do (async-runtime/aset-all! state async-runtime/VALUE-IDX @d async-runtime/STATE-IDX blk)
               :recur)
 
           ;; resume processing state machine once d has been realized
@@ -84,8 +90,8 @@
                    (let [~@(mapcat (fn [[l sym]] [sym `(^:once fn* [] ~(vary-meta l dissoc :tag))]) crossing-env)
                          f# ~(ioc/state-machine `(do ~@body) 1 [crossing-env &env] async-custom-terminators)
                          state# (-> (f#)
-                                    (ioc/aset-all! ioc/USER-START-IDX d#
-                                                   ioc/BINDINGS-IDX captured-bindings#))]
+                                    (async-runtime/aset-all! async-runtime/USER-START-IDX d#
+                                                             async-runtime/BINDINGS-IDX captured-bindings#))]
                      (run-state-machine-wrapped state#))))
        ;; chain is8 being used to apply unwrap chain
        (d/chain d#)))