Make some async api work on Scala.js and Native (#12)

* Move API only working on JVM to JVM specific code

* Move shared JS/Native code to src-js-native

* Use package private traits to add functionality

This implements a different approach which is NOT binary
compatible, but is source compatible and avoid duplicating code.
The idea is to have mixins with different implementations
for every object or trait that has functions existing on JVM
only

* Fix Js/Native and make ContextSimpleCompanionObject private

build.sc

@@ -66,6 +66,9 @@ object castor extends Module {
     def platformSegment = "js"
     def scalaJSVersion = crossScalaJsVersion
     def millSourcePath = super.millSourcePath / os.up
+    override def sources = T.sources {
+      super.sources() ++ Seq(PathRef(millSourcePath / "src-js-native"))
+    }
     object test extends Tests with ActorTestModule {
       def platformSegment = "js"
       def scalaVersion = crossScalaVersion
@@ -86,6 +89,9 @@ object castor extends Module {
     def platformSegment = "native"
     def scalaNativeVersion = crossScalaNativeVersion
     def millSourcePath = super.millSourcePath / os.up
+    override def sources = T.sources {
+      super.sources() ++ Seq(PathRef(millSourcePath / "src-js-native"))
+    }
     object test extends Tests with ActorTestModule {
       def platformSegment = "native"
     }

castor/src-js-native/Context.scala

@@ -0,0 +1,3 @@
+package castor.platform
+
+private [castor] trait Context

castor/src-js-native/ContextCompanionObject.scala

@@ -0,0 +1,5 @@
+package castor.platform
+
+private [castor] trait ContextCompanionObject {
+  private [castor] trait ContextSimpleCompanionObject
+}

castor/src-js-native/ContextImpl.scala

@@ -0,0 +1,3 @@
+package castor.platform
+
+private [castor] trait ContextImpl

castor/src-js-native/Platform.scala

@@ -0,0 +1,7 @@
+package castor.platform
+
+import scala.concurrent.ExecutionContext
+
+private [castor] object Platform {
+  def executionContext = ExecutionContext.global
+}

castor/src-jvm/castor/platform/Context.scala

@@ -0,0 +1,9 @@
+package castor.platform
+
+import castor._
+
+private [castor] trait Context {
+  def scheduleMsg[T](a: Actor[T], msg: T, time: java.time.Duration)
+                    (implicit fileName: sourcecode.FileName,
+                    line: sourcecode.Line): Unit
+}

castor/src-jvm/castor/platform/ContextCompanionObject.scala

@@ -0,0 +1,47 @@
+package castor.platform
+
+import castor._
+
+import scala.concurrent.ExecutionContext
+
+import java.util.concurrent.{Executors, ThreadFactory}
+
+private [castor] trait ContextCompanionObject {
+  /**
+   * Castor actor context based on a fixed thread pool
+   */
+  def makeThreadPool(numThreads: Int, daemon: Boolean) = Executors.newFixedThreadPool(
+    numThreads,
+    new ThreadFactory {
+      override def newThread(r: Runnable) = {
+        val t = new Thread(r)
+        t.setDaemon(daemon)
+        t
+      }
+    }
+  )
+  class ThreadPool(numThreads: Int = Runtime.getRuntime().availableProcessors(),
+                    daemon: Boolean = true,
+                    logEx: Throwable => Unit = _.printStackTrace()) extends Context.Impl{
+    val threadPool = makeThreadPool(numThreads, daemon)
+
+    val executionContext = ExecutionContext.fromExecutorService(threadPool)
+
+    def reportFailure(cause: Throwable): Unit = logEx(cause)
+    def shutdown() = threadPool.shutdownNow()
+  }
+
+  /**
+   * [[castor.Context.ThreadPool]] used for testing; tracks scheduling and completion of
+   * tasks and futures, so we can support a `.waitForInactivity()` method to wait
+   * until the system is quiescient
+   */
+  class TestThreadPool(numThreads: Int = Runtime.getRuntime().availableProcessors(),
+                        daemon: Boolean = true,
+                        logEx: Throwable => Unit = _.printStackTrace())
+    extends ThreadPool(numThreads, daemon, logEx) with Context.TestBase
+
+  private [castor] trait ContextSimpleCompanionObject {
+    lazy val threadPool = makeThreadPool(Runtime.getRuntime().availableProcessors(), true)
+  }
+}

castor/src-jvm/castor/platform/ContextImpl.scala

@@ -0,0 +1,34 @@
+package castor.platform
+
+import java.util.concurrent.{Executors, ThreadFactory, TimeUnit}
+
+import castor._
+
+private [castor] trait ContextImpl extends Context { this: Context.Impl =>
+  lazy val scheduler = Executors.newSingleThreadScheduledExecutor(
+    new ThreadFactory {
+      def newThread(r: Runnable): Thread = {
+        val t = new Thread(r, "ActorContext-Scheduler-Thread")
+        t.setDaemon(true)
+        t
+      }
+    }
+  )
+
+  def scheduleMsg[T](a: Actor[T],
+                    msg: T, delay: java.time.Duration)
+                    (implicit fileName: sourcecode.FileName,
+                    line: sourcecode.Line) = {
+    val token = reportSchedule(a, msg, fileName, line)
+    scheduler.schedule[Unit](
+      new java.util.concurrent.Callable[Unit] {
+        def call(): Unit = {
+          a.send(msg)(fileName, line)
+          reportComplete(token)
+        }
+      },
+      delay.toMillis,
+      TimeUnit.MILLISECONDS
+    )
+  }
+}

castor/src-jvm/castor/platform/Platform.scala

@@ -0,0 +1,11 @@
+package castor.platform
+
+import castor._
+
+import scala.concurrent.ExecutionContext
+
+import java.util.concurrent.{Executors, ThreadFactory, TimeUnit}
+
+private [castor] object Platform {
+  def executionContext = ExecutionContext.fromExecutorService(Context.Simple.threadPool)
+}

castor/src/Actor.scala

@@ -0,0 +1,11 @@
+package castor
+
+trait Actor[T]{
+  def send(t: T)
+          (implicit fileName: sourcecode.FileName,
+           line: sourcecode.Line): Unit
+
+  def sendAsync(f: scala.concurrent.Future[T])
+               (implicit fileName: sourcecode.FileName,
+                line: sourcecode.Line): Unit
+}

castor/src/Context.scala

@@ -1,4 +1,5 @@
 package castor
+
 import java.util.concurrent.{Executors, ThreadFactory, TimeUnit}
 
 import scala.concurrent.{Await, ExecutionContext, Future, Promise}
@@ -8,7 +9,7 @@ import scala.concurrent.{Await, ExecutionContext, Future, Promise}
  * schedule messages to be sent later, and hooks to track the current number of
  * outstanding tasks or log the actor message sends for debugging purposes
  */
-trait Context extends ExecutionContext {
+trait Context extends ExecutionContext with platform.Context {
   def reportSchedule(): Context.Token = new Context.Token.Simple()
 
   def reportSchedule(fileName: sourcecode.FileName,
@@ -29,18 +30,14 @@ trait Context extends ExecutionContext {
 
   def reportComplete(token: Context.Token): Unit = ()
 
-  def scheduleMsg[T](a: Actor[T], msg: T, time: java.time.Duration)
-                    (implicit fileName: sourcecode.FileName,
-                     line: sourcecode.Line): Unit
-
   def future[T](t: => T)
                (implicit fileName: sourcecode.FileName,
                 line: sourcecode.Line): Future[T]
 
   def execute(runnable: Runnable): Unit
 }
 
-object Context{
+object Context extends platform.ContextCompanionObject {
   trait Token
   object Token{
     class Simple extends Token(){
@@ -72,35 +69,10 @@ object Context{
     def reportFailure(t: Throwable) = logEx(t)
   }
 
-  object Simple{
-    lazy val threadPool = makeThreadPool(Runtime.getRuntime().availableProcessors(), true)
-    lazy val executionContext = ExecutionContext.fromExecutorService(threadPool)
+  object Simple extends ContextSimpleCompanionObject {
+    lazy val executionContext = platform.Platform.executionContext
     implicit lazy val global: Simple = new Simple(executionContext, _.printStackTrace())
   }
-  def makeThreadPool(numThreads: Int, daemon: Boolean) = Executors.newFixedThreadPool(
-    numThreads,
-    new ThreadFactory {
-      override def newThread(r: Runnable) = {
-        val t = new Thread(r)
-        t.setDaemon(daemon)
-        t
-      }
-    }
-  )
-
-  /**
-   * Castor actor context based on a fixed thread pool
-   */
-  class ThreadPool(numThreads: Int = Runtime.getRuntime().availableProcessors(),
-                   daemon: Boolean = true,
-                   logEx: Throwable => Unit = _.printStackTrace()) extends Context.Impl{
-    val threadPool = makeThreadPool(numThreads, daemon)
-
-    val executionContext = ExecutionContext.fromExecutorService(threadPool)
-
-    def reportFailure(cause: Throwable): Unit = logEx(cause)
-    def shutdown() = threadPool.shutdownNow()
-  }
 
   /**
    * [[castor.Context.Simple]] used for testing; tracks scheduling and completion of
@@ -111,16 +83,6 @@ object Context{
              logEx: Throwable => Unit = _.printStackTrace())
     extends Simple(executionContext, logEx) with TestBase
 
-  /**
-   * [[castor.Context.ThreadPool]] used for testing; tracks scheduling and completion of
-   * tasks and futures, so we can support a `.waitForInactivity()` method to wait
-   * until the system is quiescient
-   */
-  class TestThreadPool(numThreads: Int = Runtime.getRuntime().availableProcessors(),
-                       daemon: Boolean = true,
-                       logEx: Throwable => Unit = _.printStackTrace())
-    extends ThreadPool(numThreads, daemon, logEx) with TestBase
-
   trait TestBase extends Context.Impl {
     def executionContext: ExecutionContext
     private[this] val active = collection.mutable.Set.empty[Context.Token]
@@ -167,7 +129,7 @@ object Context{
     }
   }
 
-  trait Impl extends Context {
+  trait Impl extends Context with platform.ContextImpl {
     def executionContext: ExecutionContext
 
     def execute(runnable: Runnable): Unit = {
@@ -193,43 +155,6 @@ object Context{
       })
       p.future
     }
-
-    lazy val scheduler = Executors.newSingleThreadScheduledExecutor(
-      new ThreadFactory {
-        def newThread(r: Runnable): Thread = {
-          val t = new Thread(r, "ActorContext-Scheduler-Thread")
-          t.setDaemon(true)
-          t
-        }
-      }
-    )
-
-    def scheduleMsg[T](a: Actor[T],
-                       msg: T, delay: java.time.Duration)
-                      (implicit fileName: sourcecode.FileName,
-                       line: sourcecode.Line) = {
-      val token = reportSchedule(a, msg, fileName, line)
-      scheduler.schedule[Unit](
-        new java.util.concurrent.Callable[Unit] {
-          def call(): Unit = {
-            a.send(msg)(fileName, line)
-            reportComplete(token)
-          }
-        },
-        delay.toMillis,
-        TimeUnit.MILLISECONDS
-      )
-    }
   }
 
 }
-
-trait Actor[T]{
-  def send(t: T)
-          (implicit fileName: sourcecode.FileName,
-           line: sourcecode.Line): Unit
-
-  def sendAsync(f: scala.concurrent.Future[T])
-               (implicit fileName: sourcecode.FileName,
-                line: sourcecode.Line): Unit
-}

castor/test/src/ActorsTest.scala

@@ -13,5 +13,13 @@ object ActorsTest extends TestSuite{
         }
       }
     }
+    test("async"){
+      import Context.Simple.global
+      import scala.concurrent.Future
+      object foo extends SimpleActor[Unit]{
+        def run(msg: Unit) = ()
+      }
+      foo.sendAsync(Future(()))
+    }
   }
-}
+}