Merge pull request #20 from shogowada/develop

Develop

Author: shogowada

README.md

@@ -10,8 +10,8 @@ The library has no opinion about how the string should be passed between server
 
 |Component|SBT|Scala Version|Scala JS Version|
 |---|---|---|---|
-|scala-json-rpc|```"io.github.shogowada" %%% "scala-json-rpc" % "0.4.0"```|2.12|0.6|
-|[scala-json-rpc-upickle-json-serializer](/upickle-json-serializer)|```"io.github.shogowada" %%% "scala-json-rpc-upickle-json-serializer" % "0.4.0"```|2.12|0.6|
+|scala-json-rpc|```"io.github.shogowada" %%% "scala-json-rpc" % "0.4.1"```|2.12|0.6|
+|[scala-json-rpc-upickle-json-serializer](/upickle-json-serializer)|```"io.github.shogowada" %%% "scala-json-rpc-upickle-json-serializer" % "0.4.1"```|2.12|0.6|
 
 It supports the following features:
 

build.sbt

@@ -12,7 +12,7 @@ publishArtifact := false
 val commonSettings = Seq(
   organization := "io.github.shogowada",
   name := "scala-json-rpc",
-  version := "0.4.0",
+  version := "0.4.1",
   scalaVersion := "2.12.1",
   logBuffered in Test := false,
   licenses := Seq("MIT" -> url("https://opensource.org/licenses/MIT")),

shared/src/main/scala/io/github/shogowada/scala/jsonrpc/JsonRpcServerAndClient.scala

@@ -32,27 +32,45 @@ object JsonRpcServerAndClient {
 object JsonRpcServerAndClientMacro {
   def bindApi[API: c.WeakTypeTag](c: blackbox.Context)(api: c.Expr[API]): c.Expr[Unit] = {
     import c.universe._
-    val server = q"${c.prefix.tree}.server"
-    val client = q"${c.prefix.tree}.client"
-    JsonRpcServerMacro.bindApiImpl[c.type, API](c)(server, Some(client), api)
+    val macroUtils = JsonRpcMacroUtils[c.type](c)
+    val (serverAndClientDefinition, serverAndClient) = macroUtils.prefixDefinitionAndReference
+    val server = q"$serverAndClient.server"
+    val client = q"$serverAndClient.client"
+    val bindApi = JsonRpcServerMacro.bindApiImpl[c.type, API](c)(server, Some(client), api)
+    c.Expr[Unit](
+      q"""
+          $serverAndClientDefinition
+          $bindApi
+          """
+    )
   }
 
   def createApi[API: c.WeakTypeTag](c: blackbox.Context): c.Expr[API] = {
     import c.universe._
-    val server = q"${c.prefix.tree}.server"
-    val client = q"${c.prefix.tree}.client"
-    JsonRpcClientMacro.createApiImpl[c.type, API](c)(client, Some(server))
+    val macroUtils = JsonRpcMacroUtils[c.type](c)
+    val (serverAndClientDefinition, serverAndClient) = macroUtils.prefixDefinitionAndReference
+    val server = q"$serverAndClient.server"
+    val client = q"$serverAndClient.client"
+    val createApi = JsonRpcClientMacro.createApiImpl[c.type, API](c)(client, Some(server))
+    c.Expr[API](
+      q"""
+          $serverAndClientDefinition
+          $createApi
+          """
+    )
   }
 
   def receive(c: blackbox.Context)(json: c.Expr[String]): c.Expr[Unit] = {
     import c.universe._
     val macroUtils = JsonRpcMacroUtils[c.type](c)
-    val client: Tree = q"${c.prefix.tree}.client"
-    val server: Tree = q"${c.prefix.tree}.server"
+    val (serverAndClientDefinition, serverAndClient) = macroUtils.prefixDefinitionAndReference
+    val server: Tree = q"$serverAndClient.server"
+    val client: Tree = q"$serverAndClient.client"
     val executionContext: c.Expr[ExecutionContext] = c.Expr(q"$server.executionContext")
     c.Expr[Unit](
       q"""
           ..${macroUtils.imports}
+          $serverAndClientDefinition
           val wasJsonRpcResponse: Boolean = $client.receive($json)
           if (!wasJsonRpcResponse) {
             $server.receive($json)

shared/src/main/scala/io/github/shogowada/scala/jsonrpc/client/JsonRpcClient.scala

@@ -40,8 +40,15 @@ object JsonRpcClient {
 object JsonRpcClientMacro {
   def createApi[API: c.WeakTypeTag](c: blackbox.Context): c.Expr[API] = {
     import c.universe._
-    val client: Tree = c.prefix.tree
-    createApiImpl[c.type, API](c)(client, None)
+    val macroUtils = JsonRpcMacroUtils[c.type](c)
+    val (clientDefinition, client) = macroUtils.prefixDefinitionAndReference
+    val api = createApiImpl[c.type, API](c)(client, None)
+    c.Expr[API](
+      q"""
+          $clientDefinition
+          $api
+          """
+    )
   }
 
   def createApiImpl[CONTEXT <: blackbox.Context, API: c.WeakTypeTag](c: CONTEXT)(
@@ -114,7 +121,7 @@ object JsonRpcClientMacro {
 
     val macroUtils = JsonRpcMacroUtils[c.type](c)
 
-    val client = c.prefix.tree
+    val (clientDefinition, client) = macroUtils.prefixDefinitionAndReference
     val jsonSerializer: Tree = q"$client.jsonSerializer"
     val promisedResponseRepository: Tree = q"$client.promisedResponseRepository"
 
@@ -136,6 +143,7 @@ object JsonRpcClientMacro {
     c.Expr[Boolean](
       q"""
           ..${macroUtils.imports}
+          $clientDefinition
           $maybePromisedResponse
               .map(promisedResponse => {
                 promisedResponse.success($json)

shared/src/main/scala/io/github/shogowada/scala/jsonrpc/client/JsonRpcMethodClientFactoryMacro.scala

@@ -96,7 +96,6 @@ class JsonRpcMethodClientFactoryMacro[CONTEXT <: blackbox.Context](val c: CONTEX
       jsonRpcFunctionType: Type
   ): Tree = {
     val requestJsonHandlerRepository = macroUtils.getRequestJsonHandlerRepository(server)
-
     val jsonRpcFunctionMethodNameRepository = macroUtils.getJsonRpcFunctionMethodNameRepository(client)
 
     val disposeFunctionMethodHandler = requestJsonHandlerFactoryMacro.createDisposeFunctionMethodHandler(server, client)

shared/src/main/scala/io/github/shogowada/scala/jsonrpc/server/JsonRpcServer.scala

@@ -32,7 +32,16 @@ object JsonRpcServer {
 
 object JsonRpcServerMacro {
   def bindApi[API: c.WeakTypeTag](c: blackbox.Context)(api: c.Expr[API]): c.Expr[Unit] = {
-    bindApiImpl[c.type, API](c)(c.prefix.tree, None, api)
+    import c.universe._
+    val macroUtils = JsonRpcMacroUtils[c.type](c)
+    val (serverDefinition, server) = macroUtils.prefixDefinitionAndReference
+    val bind = bindApiImpl[c.type, API](c)(server, None, api)
+    c.Expr[Unit](
+      q"""
+          $serverDefinition
+          $bind
+          """
+    )
   }
 
   def bindApiImpl[CONTEXT <: blackbox.Context, API: c.WeakTypeTag](c: CONTEXT)(
@@ -81,10 +90,10 @@ object JsonRpcServerMacro {
 
     val macroUtils = JsonRpcMacroUtils[c.type](c)
 
-    val server = c.prefix.tree
-    val jsonSerializer: Tree = q"$server.jsonSerializer"
+    val (serverDefinition, server) = macroUtils.prefixDefinitionAndReference
+    val jsonSerializer: Tree = macroUtils.getJsonSerializer(server)
     val requestJsonHandlerRepository = macroUtils.getRequestJsonHandlerRepository(server)
-    val executionContext: Tree = q"$server.executionContext"
+    val executionContext: Tree = macroUtils.getExecutionContext(server)
 
     val maybeParseErrorJson: c.Expr[Option[String]] =
       macroUtils.createMaybeErrorJson(server, json, c.Expr[JsonRpcError[String]](q"JsonRpcErrors.parseError"))
@@ -129,6 +138,7 @@ object JsonRpcServerMacro {
     c.Expr(
       q"""
           ..${macroUtils.imports}
+          $serverDefinition
           $futureMaybeJson
           """
     )

shared/src/main/scala/io/github/shogowada/scala/jsonrpc/utils/JsonRpcMacroUtils.scala

@@ -38,6 +38,22 @@ class JsonRpcMacroUtils[CONTEXT <: blackbox.Context](val c: CONTEXT) {
 
   def getExecutionContext(prefix: Tree): Tree = q"$prefix.executionContext"
 
+  def prefixDefinitionAndReference: (Tree, Tree) = {
+    // We do this instead of using c.prefix.tree directly to make sure the reference
+    // used at the point of macro expansion will always be used for the macro.
+    // For example, if you have the following code
+    //
+    // server.bindApi[Api]
+    // server = null
+    //
+    // then the API bound will break because its c.prefix.tree is now changed to null.
+    val prefixTermName = TermName(c.freshName())
+    (
+        q"val $prefixTermName = ${c.prefix.tree}",
+        q"$prefixTermName"
+    )
+  }
+
   def getJsonRpcApiMethods(apiType: Type): Iterable[MethodSymbol] = {
     apiType.decls
         .filter((apiMember: Symbol) => isJsonRpcMethod(apiMember))

shared/src/test/scala/io/github/shogowada/scala/jsonrpc/JsonRpcServerAndClientTest.scala

@@ -27,8 +27,8 @@ class JsonRpcServerAndClientTest extends AsyncFunSpec
       val client1 = JsonRpcClient(jsonSerializer, (json: String) => server2.receive(json))
       val client2 = JsonRpcClient(jsonSerializer, (json: String) => server1.receive(json))
 
-      val serverAndClient1 = JsonRpcServerAndClient(server1, client1)
-      val serverAndClient2 = JsonRpcServerAndClient(server2, client2)
+      var serverAndClient1 = JsonRpcServerAndClient(server1, client1)
+      var serverAndClient2 = JsonRpcServerAndClient(server2, client2)
     }
 
     describe("and I have an API that takes function as parameter") {
@@ -210,7 +210,7 @@ class JsonRpcServerAndClientTest extends AsyncFunSpec
           client.foo2(() => {})
         }
 
-        it("then it should use differeht function references on the server too") {
+        it("then it should use different function references on the server too") {
           val fixture = new CallThemBothWithDifferentFunctions
           for {
             foo1Function <- fixture.promisedFoo1Function.future
@@ -219,5 +219,31 @@ class JsonRpcServerAndClientTest extends AsyncFunSpec
         }
       }
     }
+
+    describe("and I changed the reference to servers and clients") {
+      class IChangedTheReference extends TwoServersAndClients {
+
+        trait Api {
+          def foo(): Future[String]
+        }
+
+        class ApiImpl extends Api {
+          override def foo(): Future[String] = {
+            Future("foo")
+          }
+        }
+
+        serverAndClient1.bindApi[Api](new ApiImpl)
+        val api = serverAndClient2.createApi[Api]
+
+        serverAndClient1 = null
+        serverAndClient2 = null
+      }
+
+      it("but the APIs should still work") {
+        val fixture = new IChangedTheReference
+        fixture.api.foo().map(result => result should equal("foo"))
+      }
+    }
   }
 }