Add support for endpoints with glob-pattern methods

Author: Baccata

fs2/src/jsonrpclib/fs2/FS2Channel.scala

@@ -16,6 +16,7 @@ import jsonrpclib.internals.MessageDispatcher
 import jsonrpclib.internals._
 
 import scala.util.Try
+import java.util.regex.Pattern
 
 trait FS2Channel[F[_]] extends Channel[F] {
 
@@ -52,7 +53,7 @@ object FS2Channel {
   ): Stream[F, FS2Channel[F]] = {
     for {
       supervisor <- Stream.resource(Supervisor[F])
-      ref <- Ref[F].of(State[F](Map.empty, Map.empty, Map.empty, 0)).toStream
+      ref <- Ref[F].of(State[F](Map.empty, Map.empty, Map.empty, Vector.empty, 0)).toStream
       queue <- cats.effect.std.Queue.bounded[F, Payload](bufferSize).toStream
       impl = new Impl(queue, ref, supervisor, cancelTemplate)
 
@@ -73,6 +74,7 @@ object FS2Channel {
       runningCalls: Map[CallId, Fiber[F, Throwable, Unit]],
       pendingCalls: Map[CallId, OutputMessage => F[Unit]],
       endpoints: Map[String, Endpoint[F]],
+      globEndpoints: Vector[(Pattern, Endpoint[F])],
       counter: Long
   ) {
     def nextCallId: (State[F], CallId) = (this.copy(counter = counter + 1), CallId.NumberId(counter))
@@ -82,11 +84,27 @@ object FS2Channel {
       val result = pendingCalls.get(callId)
       (this.copy(pendingCalls = pendingCalls.removed(callId)), result)
     }
-    def mountEndpoint(endpoint: Endpoint[F]): Either[ConflictingMethodError, State[F]] =
-      endpoints.get(endpoint.method) match {
-        case None    => Right(this.copy(endpoints = endpoints + (endpoint.method -> endpoint)))
-        case Some(_) => Left(ConflictingMethodError(endpoint.method))
+    def mountEndpoint(endpoint: Endpoint[F]): Either[ConflictingMethodError, State[F]] = {
+      import endpoint.method
+      if (method.contains("*")) {
+        val parts = method
+          .split("\\*", -1)
+          .map { // Don't discard trailing empty string, if any.
+            case ""  => ""
+            case str => Pattern.quote(str)
+          }
+        val glob = Pattern.compile(parts.mkString(".*"))
+        Right(this.copy(globEndpoints = globEndpoints :+ (glob -> endpoint)))
+      } else {
+        endpoints.get(endpoint.method) match {
+          case None    => Right(this.copy(endpoints = endpoints + (endpoint.method -> endpoint)))
+          case Some(_) => Left(ConflictingMethodError(endpoint.method))
+        }
       }
+    }
+    def getEndpoint(method: String): Option[Endpoint[F]] = {
+      endpoints.get(method).orElse(globEndpoints.find(_._1.matcher(method).matches()).map(_._2))
+    }
     def removeEndpoint(method: String): State[F] =
       copy(endpoints = endpoints.removed(method))
 
@@ -135,7 +153,7 @@ object FS2Channel {
           }
       }
     protected def reportError(params: Option[Payload], error: ProtocolError, method: String): F[Unit] = ???
-    protected def getEndpoint(method: String): F[Option[Endpoint[F]]] = state.get.map(_.endpoints.get(method))
+    protected def getEndpoint(method: String): F[Option[Endpoint[F]]] = state.get.map(_.getEndpoint(method))
     protected def sendMessage(message: Message): F[Unit] = queue.offer(Codec.encode(message))
 
     protected def nextCallId(): F[CallId] = state.modify(_.nextCallId)

fs2/test/src/jsonrpclib/fs2/FS2ChannelSpec.scala

@@ -54,6 +54,32 @@ object FS2ChannelSpec extends SimpleIOSuite {
     }
   }
 
+  testRes("Round trip (glob)") {
+    val endpoint: Endpoint[IO] = Endpoint[IO]("**").simple((int: IntWrapper) => IO(IntWrapper(int.int + 1)))
+
+    for {
+      clientSideChannel <- setup(endpoint)
+      remoteFunction = clientSideChannel.simpleStub[IntWrapper, IntWrapper]("inc/test")
+      result <- remoteFunction(IntWrapper(1)).toStream
+    } yield {
+      expect.same(result, IntWrapper(2))
+    }
+  }
+
+  testRes("Globs have lower priority than strict endpoints") {
+    val endpoint: Endpoint[IO] = Endpoint[IO]("inc").simple((int: IntWrapper) => IO(IntWrapper(int.int + 1)))
+    val globEndpoint: Endpoint[IO] =
+      Endpoint[IO]("**").simple((_: IntWrapper) => IO.raiseError[IntWrapper](new Throwable("Boom")))
+
+    for {
+      clientSideChannel <- setup(globEndpoint, endpoint)
+      remoteFunction = clientSideChannel.simpleStub[IntWrapper, IntWrapper]("inc")
+      result <- remoteFunction(IntWrapper(1)).toStream
+    } yield {
+      expect.same(result, IntWrapper(2))
+    }
+  }
+
   testRes("Endpoint not mounted") {
 
     for {