big refactoring in preparation for allowing endpoint filters

3 files changed, 38 insertions, 29 deletions

diff --git a/cask/src/cask/main/ErrorMsgs.scala b/cask/src/cask/main/ErrorMsgs.scala
index f762f3a..c5ce978 100644
--- a/cask/src/cask/main/ErrorMsgs.scala
+++ b/cask/src/cask/main/ErrorMsgs.scala
@@ -37,11 +37,11 @@ object ErrorMsgs {
   }
 
   def formatMainMethodSignature[T](base: T,
-                                   main: Router.EntryPoint[_, T, _],
+                                   main: Router.EntryPoint[T, _],
                                    leftIndent: Int,
                                    leftColWidth: Int) = {
     // +2 for space on right of left col
-    val args = main.argSignatures.map(renderArg(base, _, leftColWidth + leftIndent + 2 + 2, 80))
+    val args = main.argSignatures.last.map(as => renderArg(base, as, leftColWidth + leftIndent + 2 + 2, 80))
 
     val leftIndentStr = " " * leftIndent
     val argStrings =
@@ -60,7 +60,7 @@ object ErrorMsgs {
        |${argStrings.map(_ + "\n").mkString}""".stripMargin
   }
 
-  def formatInvokeError[T](base: T, route: Router.EntryPoint[_, T, _], x: Router.Result.Error): String = {
+  def formatInvokeError[T](base: T, route: Router.EntryPoint[T, _], x: Router.Result.Error): String = {
     def expectedMsg = formatMainMethodSignature(base: T, route, 0, 0)
 
     x match{
diff --git a/cask/src/cask/main/Main.scala b/cask/src/cask/main/Main.scala
index 9acaf19..bfb058e 100644
--- a/cask/src/cask/main/Main.scala
+++ b/cask/src/cask/main/Main.scala
@@ -31,8 +31,8 @@ abstract class BaseMain{
   lazy val routeTries = Seq("get", "put", "post")
     .map { method =>
       method -> DispatchTrie.construct[(Routes, Routes.EndpointMetadata[_])](0,
-        for ((route, metadata) <- routeList if metadata.endpoint.methods.contains(method))
-          yield (Util.splitPath(metadata.endpoint.path): IndexedSeq[String], (route, metadata), metadata.endpoint.subpath)
+        for ((route, metadata) <- routeList if metadata.endpoints.exists(_.methods.contains(method)))
+        yield (Util.splitPath(metadata.endpoints.last.path): IndexedSeq[String], (route, metadata), metadata.endpoints.last.subpath)
       )
     }.toMap
 
@@ -59,22 +59,21 @@ abstract class BaseMain{
       routeTries(exchange.getRequestMethod.toString.toLowerCase()).lookup(Util.splitPath(exchange.getRequestPath).toList, Map()) match{
         case None => writeResponse(exchange, handleError(404))
         case Some(((routes, metadata), bindings, remaining)) =>
-          val result = metadata.endpoint.handle(
-            ParamContext(exchange, remaining), bindings, routes,
-            metadata.entryPoint.asInstanceOf[
-              EntryPoint[metadata.endpoint.InputType, cask.main.Routes, cask.model.ParamContext]
-            ]
+          val providers = metadata.endpoints.map(e =>
+            e.handle(ParamContext(exchange, remaining)) ++ bindings.mapValues(e.wrapPathSegment)
           )
-
+          val result = metadata.entryPoint
+            .asInstanceOf[EntryPoint[cask.main.Routes, cask.model.ParamContext]]
+            .invoke(routes, ParamContext(exchange, remaining), providers)
           result match{
-            case Router.Result.Success(response) => writeResponse(exchange, response)
+            case Router.Result.Success(response: BaseResponse) => writeResponse(exchange, response)
             case e: Router.Result.Error =>
 
               writeResponse(exchange,
                 Response(
                   ErrorMsgs.formatInvokeError(
                     routes,
-                    metadata.entryPoint.asInstanceOf[EntryPoint[_, cask.main.Routes, _]],
+                    metadata.entryPoint.asInstanceOf[EntryPoint[cask.main.Routes, _]],
                     e
                   ),
                   statusCode = 500)
diff --git a/cask/src/cask/main/Routes.scala b/cask/src/cask/main/Routes.scala
index ee2b2b9..7299276 100644
--- a/cask/src/cask/main/Routes.scala
+++ b/cask/src/cask/main/Routes.scala
@@ -14,15 +14,13 @@ object Routes{
     val path: String
     val methods: Seq[String]
     def subpath: Boolean = false
-    def wrapMethodOutput(t: R): Any
-    def handle(ctx: ParamContext,
-               bindings: Map[String, String],
-               routes: Routes,
-               entryPoint: EntryPoint[InputType, Routes, cask.model.ParamContext]): Router.Result[BaseResponse]
+    def wrapMethodOutput(ctx: ParamContext,t: R): cask.internal.Router.Result[Any] = cask.internal.Router.Result.Success(t)
+    def handle(ctx: ParamContext): Map[String, InputType]
+    def wrapPathSegment(s: String): InputType
   }
 
-  case class EndpointMetadata[T](endpoint: Endpoint[_],
-                                 entryPoint: EntryPoint[_, T, ParamContext])
+  case class EndpointMetadata[T](endpoints: Seq[Endpoint[_]],
+                                 entryPoint: EntryPoint[T, ParamContext])
   case class RoutesEndpointsMetadata[T](value: EndpointMetadata[T]*)
   object RoutesEndpointsMetadata{
     implicit def initialize[T] = macro initializeImpl[T]
@@ -32,27 +30,39 @@ object Routes{
 
       val routeParts = for{
         m <- c.weakTypeOf[T].members
-        annot <- m.annotations.filter(_.tree.tpe <:< c.weakTypeOf[Endpoint[_]])
+        val annotations = m.annotations.filter(_.tree.tpe <:< c.weakTypeOf[Endpoint[_]])
+        if annotations.nonEmpty
       } yield {
-        val annotObject = q"new ${annot.tree.tpe}(..${annot.tree.children.tail})"
-        val annotObjectSym = c.universe.TermName(c.freshName("annotObject"))
+
+        val annotObjects =
+          for(annot <- annotations)
+          yield q"new ${annot.tree.tpe}(..${annot.tree.children.tail})"
+        val annotObjectSyms =
+          for(_ <- annotations.indices)
+          yield c.universe.TermName(c.freshName("annotObject"))
         val route = router.extractMethod(
           m.asInstanceOf[MethodSymbol],
           weakTypeOf[T],
-          (t: router.c.universe.Tree) => q"$annotObjectSym.wrapMethodOutput($t)",
+          (t: router.c.universe.Tree) => q"${annotObjectSyms.last}.wrapMethodOutput(ctx, $t)",
           c.weakTypeOf[ParamContext],
-          q"$annotObjectSym.parseMethodInput",
-          tq"$annotObjectSym.InputType"
+          annotObjectSyms.map(annotObjectSym => q"$annotObjectSym.parseMethodInput"),
+          annotObjectSyms.map(annotObjectSym => tq"$annotObjectSym.InputType")
+
         )
 
+        val declarations =
+          for((sym, obj) <- annotObjectSyms.zip(annotObjects))
+          yield q"val $sym = $obj"
 
-        q"""{
-          val $annotObjectSym = $annotObject
+        val res = q"""{
+          ..$declarations
           cask.main.Routes.EndpointMetadata(
-            $annotObjectSym,
+            Seq(..$annotObjectSyms),
             $route
           )
         }"""
+//        println(res)
+        res
       }
 
       c.Expr[RoutesEndpointsMetadata[T]](q"""cask.main.Routes.RoutesEndpointsMetadata(..$routeParts)""")