Make `Input` a type param too

9 files changed, 26 insertions, 35 deletions

diff --git a/cask/src/cask/endpoints/FormEndpoint.scala b/cask/src/cask/endpoints/FormEndpoint.scala
index 264c169..38ce994 100644
--- a/cask/src/cask/endpoints/FormEndpoint.scala
+++ b/cask/src/cask/endpoints/FormEndpoint.scala
@@ -44,10 +44,9 @@ object FormReader{
   }
 }
 class postForm(val path: String, override val subpath: Boolean = false)
-  extends Endpoint[Response.Raw] {
+  extends Endpoint[Response.Raw, Seq[FormEntry]] {
 
   val methods = Seq("post")
-  type Input = Seq[FormEntry]
   type InputParser[T] = FormReader[T]
   def wrapFunction(ctx: Request,
                        delegate: Delegate): Router.Result[Response.Raw] = {
@@ -68,6 +67,6 @@ class postForm(val path: String, override val subpath: Boolean = false)
     }
   }
 
-  def wrapPathSegment(s: String): Input = Seq(FormValue(s, new io.undertow.util.HeaderMap))
+  def wrapPathSegment(s: String): Seq[FormEntry] = Seq(FormValue(s, new io.undertow.util.HeaderMap))
 }
 
diff --git a/cask/src/cask/endpoints/JsonEndpoint.scala b/cask/src/cask/endpoints/JsonEndpoint.scala
index 2e3373f..c4740fd 100644
--- a/cask/src/cask/endpoints/JsonEndpoint.scala
+++ b/cask/src/cask/endpoints/JsonEndpoint.scala
@@ -40,9 +40,8 @@ object JsonData extends DataCompanion[JsonData]{
 }
 
 class postJson(val path: String, override val subpath: Boolean = false)
-  extends Endpoint[Response[JsonData]]{
+  extends Endpoint[Response[JsonData], ujson.Value]{
   val methods = Seq("post")
-  type Input = ujson.Value
   type InputParser[T] = JsReader[T]
   override type OuterReturned = Router.Result[Response.Raw]
   def wrapFunction(ctx: Request,
@@ -76,13 +75,12 @@ class postJson(val path: String, override val subpath: Boolean = false)
       case Right(params) => delegate(params)
     }
   }
-  def wrapPathSegment(s: String): Input = ujson.Str(s)
+  def wrapPathSegment(s: String): ujson.Value = ujson.Str(s)
 }
 
 class getJson(val path: String, override val subpath: Boolean = false)
-  extends Endpoint[Response[JsonData]]{
+  extends Endpoint[Response[JsonData], Seq[String]]{
   val methods = Seq("get")
-  type Input = Seq[String]
   type InputParser[T] = QueryParamReader[T]
   override type OuterReturned = Router.Result[Response.Raw]
   def wrapFunction(ctx: Request, delegate: Delegate): Router.Result[Response.Raw] = {
diff --git a/cask/src/cask/endpoints/StaticEndpoints.scala b/cask/src/cask/endpoints/StaticEndpoints.scala
index bf99d09..2f0568d 100644
--- a/cask/src/cask/endpoints/StaticEndpoints.scala
+++ b/cask/src/cask/endpoints/StaticEndpoints.scala
@@ -3,9 +3,8 @@ package cask.endpoints
 import cask.main.Endpoint
 import cask.model.Request
 
-class staticFiles(val path: String) extends Endpoint[String]{
+class staticFiles(val path: String) extends Endpoint[String, Seq[String]]{
   val methods = Seq("get")
-  type Input = Seq[String]
   type InputParser[T] = QueryParamReader[T]
   override def subpath = true
   def wrapFunction(ctx: Request, delegate: Delegate): OuterReturned = {
@@ -18,13 +17,12 @@ class staticFiles(val path: String) extends Endpoint[String]{
     )
   }
 
-  def wrapPathSegment(s: String): Input = Seq(s)
+  def wrapPathSegment(s: String): Seq[String] = Seq(s)
 }
 
 class staticResources(val path: String, resourceRoot: ClassLoader = getClass.getClassLoader)
-  extends Endpoint[String]{
+  extends Endpoint[String, Seq[String]]{
   val methods = Seq("get")
-  type Input = Seq[String]
   type InputParser[T] = QueryParamReader[T]
   override def subpath = true
   def wrapFunction(ctx: Request, delegate: Delegate): OuterReturned = {
@@ -38,5 +36,5 @@ class staticResources(val path: String, resourceRoot: ClassLoader = getClass.get
     )
   }
 
-  def wrapPathSegment(s: String): Input = Seq(s)
+  def wrapPathSegment(s: String): Seq[String] = Seq(s)
 }
diff --git a/cask/src/cask/endpoints/WebEndpoints.scala b/cask/src/cask/endpoints/WebEndpoints.scala
index b52b290..ae1e178 100644
--- a/cask/src/cask/endpoints/WebEndpoints.scala
+++ b/cask/src/cask/endpoints/WebEndpoints.scala
@@ -7,8 +7,7 @@ import cask.model.{Request, Response}
 import collection.JavaConverters._
 
 
-trait WebEndpoint extends Endpoint[Response.Raw]{
-  type Input = Seq[String]
+trait WebEndpoint extends Endpoint[Response.Raw, Seq[String]]{
   type InputParser[T] = QueryParamReader[T]
   def wrapFunction(ctx: Request,
                        delegate: Delegate): Router.Result[Response.Raw] = {
diff --git a/cask/src/cask/endpoints/WebSocketEndpoint.scala b/cask/src/cask/endpoints/WebSocketEndpoint.scala
index ca2854f..dff2232 100644
--- a/cask/src/cask/endpoints/WebSocketEndpoint.scala
+++ b/cask/src/cask/endpoints/WebSocketEndpoint.scala
@@ -14,14 +14,13 @@ object WebsocketResult{
 }
 
 class websocket(val path: String, override val subpath: Boolean = false)
-  extends cask.main.BaseEndpoint[WebsocketResult]{
+  extends cask.main.BaseEndpoint[WebsocketResult, Seq[String]]{
   val methods = Seq("websocket")
-  type Input = Seq[String]
   type InputParser[T] = QueryParamReader[T]
   type OuterReturned = Router.Result[WebsocketResult]
   def wrapFunction(ctx: Request, delegate: Delegate): OuterReturned = {
     delegate(WebEndpoint.buildMapFromQueryParams(ctx))
   }
 
-  def wrapPathSegment(s: String): Input = Seq(s)
+  def wrapPathSegment(s: String): Seq[String] = Seq(s)
 }
diff --git a/cask/src/cask/main/Decorators.scala b/cask/src/cask/main/Decorators.scala
index e395d5b..dd445a4 100644
--- a/cask/src/cask/main/Decorators.scala
+++ b/cask/src/cask/main/Decorators.scala
@@ -9,7 +9,7 @@ import cask.model.{Request, Response}
   * Annotates a Cask endpoint that returns a HTTP [[Response]]; similar to a
   * [[Decorator]] but with additional metadata and capabilities.
   */
-trait Endpoint[InnerReturned] extends BaseEndpoint[InnerReturned] {
+trait Endpoint[InnerReturned, Input] extends BaseEndpoint[InnerReturned, Input] {
   type OuterReturned = Router.Result[Response.Raw]
 }
 
@@ -17,7 +17,7 @@ trait Endpoint[InnerReturned] extends BaseEndpoint[InnerReturned] {
   * An [[Endpoint]] that may return something else than a HTTP response, e.g.
   * a websocket endpoint which may instead return a websocket event handler
   */
-trait BaseEndpoint[InnerReturned] extends BaseDecorator[InnerReturned]{
+trait BaseEndpoint[InnerReturned, Input] extends BaseDecorator[InnerReturned, Input]{
   /**
     * What is the path that this particular endpoint matches?
     */
@@ -55,10 +55,10 @@ trait BaseEndpoint[InnerReturned] extends BaseDecorator[InnerReturned]{
 /**
   * A [[Decorator]] that may deal with values other than HTTP [[Response]]s
   */
-trait BaseDecorator[InnerReturned]{
-  type Input
+trait BaseDecorator[InnerReturned, Input]{
+  final type InputTypeAlias = Input
   type InputParser[T] <: ArgReader[Input, T, Request]
-  type Delegate = Map[String, Input] => Router.Result[InnerReturned]
+  final type Delegate = Map[String, Input] => Router.Result[InnerReturned]
   type OuterReturned <: Router.Result[Any]
   def wrapFunction(ctx: Request, delegate: Delegate): OuterReturned
   def getParamParser[T](implicit p: InputParser[T]) = p
@@ -75,10 +75,9 @@ trait BaseDecorator[InnerReturned]{
   * to `wrapFunction`, which takes a `Map` representing any additional argument
   * lists (if any).
   */
-trait Decorator extends BaseDecorator[Response.Raw]{
+trait Decorator extends BaseDecorator[Response.Raw, Any]{
   type OuterReturned = Router.Result[Response.Raw]
-  type Input = Any
-  type InputParser[T] = NoOpParser[Input, T]
+  type InputParser[T] = NoOpParser[Any, T]
 }
 
 class NoOpParser[Input, T] extends ArgReader[Input, T, Request] {
diff --git a/cask/src/cask/main/Main.scala b/cask/src/cask/main/Main.scala
index c3a4ace..1eb2dbc 100644
--- a/cask/src/cask/main/Main.scala
+++ b/cask/src/cask/main/Main.scala
@@ -99,7 +99,7 @@ abstract class BaseMain{
                   )
 
                 case Nil =>
-                  metadata.endpoint.wrapFunction(ctx, endpointBindings =>
+                  metadata.endpoint.wrapFunction(ctx, (endpointBindings: Map[String, Any]) =>
                     metadata.entryPoint
                       .asInstanceOf[EntryPoint[cask.main.Routes, cask.model.Request]]
                       .invoke(
diff --git a/cask/src/cask/main/Routes.scala b/cask/src/cask/main/Routes.scala
index 5b02542..ea9d6fe 100644
--- a/cask/src/cask/main/Routes.scala
+++ b/cask/src/cask/main/Routes.scala
@@ -8,7 +8,7 @@ import language.experimental.macros
 
 object Routes{
   case class EndpointMetadata[T](decorators: Seq[Decorator],
-                                 endpoint: BaseEndpoint[_],
+                                 endpoint: BaseEndpoint[_, _],
                                  entryPoint: EntryPoint[T, _])
   case class RoutesEndpointsMetadata[T](value: EndpointMetadata[T]*)
   object RoutesEndpointsMetadata{
@@ -19,15 +19,15 @@ object Routes{
 
       val routeParts = for{
         m <- c.weakTypeOf[T].members
-        val annotations = m.annotations.filter(_.tree.tpe <:< c.weakTypeOf[BaseDecorator[_]]).reverse
+        val annotations = m.annotations.filter(_.tree.tpe <:< c.weakTypeOf[BaseDecorator[_, _]]).reverse
         if annotations.nonEmpty
       } yield {
-        if(!(annotations.head.tree.tpe <:< weakTypeOf[BaseEndpoint[_]])) c.abort(
+        if(!(annotations.head.tree.tpe <:< weakTypeOf[BaseEndpoint[_, _]])) c.abort(
           annotations.head.tree.pos,
           s"Last annotation applied to a function must be an instance of Endpoint, " +
           s"not ${annotations.head.tree.tpe}"
         )
-        val allEndpoints = annotations.filter(_.tree.tpe <:< weakTypeOf[BaseEndpoint[_]])
+        val allEndpoints = annotations.filter(_.tree.tpe <:< weakTypeOf[BaseEndpoint[_, _]])
         if(allEndpoints.length > 1) c.abort(
           annotations.head.tree.pos,
           s"You can only apply one Endpoint annotation to a function, not " +
@@ -45,8 +45,7 @@ object Routes{
           q"${annotObjectSyms.head}.convertToResultType",
           tq"cask.Request",
           annotObjectSyms.map(annotObjectSym => q"$annotObjectSym.getParamParser"),
-          annotObjectSyms.map(annotObjectSym => tq"$annotObjectSym.Input")
-
+          annotObjectSyms.map(annotObjectSym => tq"$annotObjectSym.InputTypeAlias")
         )
 
         val declarations =
diff --git a/cask/src/cask/package.scala b/cask/src/cask/package.scala
index c3909ec..427f638 100644
--- a/cask/src/cask/package.scala
+++ b/cask/src/cask/package.scala
@@ -38,6 +38,6 @@ package object cask {
   val Routes = main.Routes
   type Main = main.Main
   type Decorator = main.Decorator
-  type Endpoint[InnerReturned] = main.Endpoint[InnerReturned]
+  type Endpoint[InnerReturned, Input] = main.Endpoint[InnerReturned, Input]
 
 }