`foo: CookieParam` arguments now work

6 files changed, 39 insertions, 41 deletions

diff --git a/cask/src/cask/endpoints/FormEndpoint.scala b/cask/src/cask/endpoints/FormEndpoint.scala
index 1345489..e4b28f4 100644
--- a/cask/src/cask/endpoints/FormEndpoint.scala
+++ b/cask/src/cask/endpoints/FormEndpoint.scala
@@ -9,30 +9,30 @@ import io.undertow.server.handlers.form.FormParserFactory
 
 import collection.JavaConverters._
 
-sealed trait FormReader[T] extends Router.ArgReader[Seq[FormValue], T, cask.model.ParamContext]
+sealed trait FormReader[T] extends Router.ArgReader[Seq[FormValue], T, ParamContext]
 object FormReader{
   implicit def paramFormReader[T: QueryParamReader] = new FormReader[T]{
     def arity = implicitly[QueryParamReader[T]].arity
 
-    def read(ctx: cask.model.ParamContext, input: Seq[FormValue]) = {
-      implicitly[QueryParamReader[T]].read(ctx, input.map(_.value))
+    def read(ctx: ParamContext, label: String, input: Seq[FormValue]) = {
+      implicitly[QueryParamReader[T]].read(ctx, label, input.map(_.value))
     }
   }
   implicit def formValueReader = new FormReader[FormValue]{
     def arity = 1
-    def read(ctx: cask.model.ParamContext, input: Seq[FormValue]) = input.head
+    def read(ctx: ParamContext, label: String, input: Seq[FormValue]) = input.head
   }
   implicit def formValuesReader = new FormReader[Seq[FormValue]]{
     def arity = 1
-    def read(ctx: cask.model.ParamContext, input: Seq[FormValue]) = input
+    def read(ctx: ParamContext, label: String, input: Seq[FormValue]) = input
   }
   implicit def formValueFileReader = new FormReader[FormValue.File]{
     def arity = 1
-    def read(ctx: cask.model.ParamContext, input: Seq[FormValue]) = input.head.asFile.get
+    def read(ctx: ParamContext, label: String, input: Seq[FormValue]) = input.head.asFile.get
   }
   implicit def formValuesFileReader = new FormReader[Seq[FormValue.File]]{
     def arity = 1
-    def read(ctx: cask.model.ParamContext, input: Seq[FormValue]) = input.map(_.asFile.get)
+    def read(ctx: ParamContext, label: String, input: Seq[FormValue]) = input.map(_.asFile.get)
   }
 }
 class postForm(val path: String, override val subpath: Boolean = false) extends Endpoint[Response]{
@@ -42,7 +42,7 @@ class postForm(val path: String, override val subpath: Boolean = false) extends
   def handle(ctx: ParamContext,
              bindings: Map[String, String],
              routes: Routes,
-             entryPoint: EntryPoint[Seq[FormValue], Routes, cask.model.ParamContext]): Router.Result[Response] = {
+             entryPoint: EntryPoint[Seq[FormValue], Routes, ParamContext]): Router.Result[Response] = {
 
     val formData = FormParserFactory.builder().build().createParser(ctx.exchange).parseBlocking()
     val formDataBindings =
diff --git a/cask/src/cask/endpoints/JsonEndpoint.scala b/cask/src/cask/endpoints/JsonEndpoint.scala
index 38e15fe..9ab2f90 100644
--- a/cask/src/cask/endpoints/JsonEndpoint.scala
+++ b/cask/src/cask/endpoints/JsonEndpoint.scala
@@ -12,7 +12,7 @@ object JsReader{
   implicit def defaultJsReader[T: upickle.default.Reader] = new JsReader[T]{
     def arity = 1
 
-    def read(ctx: cask.model.ParamContext, input: ujson.Js.Value): T = {
+    def read(ctx: cask.model.ParamContext, label: String, input: ujson.Js.Value): T = {
       implicitly[upickle.default.Reader[T]].apply(input)
     }
   }
@@ -20,8 +20,8 @@ object JsReader{
   implicit def paramReader[T: ParamReader] = new JsReader[T] {
     override def arity = 0
 
-    override def read(ctx: cask.model.ParamContext, v: ujson.Js.Value) = {
-      implicitly[ParamReader[T]].read(ctx, Nil)
+    override def read(ctx: cask.model.ParamContext, label: String, v: ujson.Js.Value) = {
+      implicitly[ParamReader[T]].read(ctx, label, Nil)
     }
   }
 }
diff --git a/cask/src/cask/endpoints/ParamReader.scala b/cask/src/cask/endpoints/ParamReader.scala
index 21cf3d7..f623005 100644
--- a/cask/src/cask/endpoints/ParamReader.scala
+++ b/cask/src/cask/endpoints/ParamReader.scala
@@ -2,22 +2,23 @@ package cask.endpoints
 
 import cask.Cookie
 import cask.internal.Router
+import cask.model.ParamContext
 import io.undertow.server.HttpServerExchange
 import io.undertow.server.handlers.form.{FormData, FormParserFactory}
 
 abstract class ParamReader[T]
   extends Router.ArgReader[Seq[String], T, cask.model.ParamContext]{
   def arity: Int
-  def read(ctx: cask.model.ParamContext, v: Seq[String]): T
+  def read(ctx: cask.model.ParamContext, label: String, v: Seq[String]): T
 }
 object ParamReader{
-  class NilParam[T](f: cask.model.ParamContext => T) extends ParamReader[T]{
+  class NilParam[T](f: (ParamContext, String) => T) extends ParamReader[T]{
     def arity = 0
-    def read(ctx: cask.model.ParamContext, v: Seq[String]): T = f(ctx)
+    def read(ctx: cask.model.ParamContext, label: String, v: Seq[String]): T = f(ctx, label)
   }
-  implicit object HttpExchangeParam extends NilParam[HttpServerExchange](ctx => ctx.exchange)
+  implicit object HttpExchangeParam extends NilParam[HttpServerExchange]((ctx, label) => ctx.exchange)
 
-  implicit object FormDataParam extends NilParam[FormData](ctx =>
+  implicit object FormDataParam extends NilParam[FormData]((ctx, label) =>
     FormParserFactory.builder().build().createParser(ctx.exchange).parseBlocking()
   )
 }
diff --git a/cask/src/cask/endpoints/Params.scala b/cask/src/cask/endpoints/Params.scala
index 60691f8..6ff9dc1 100644
--- a/cask/src/cask/endpoints/Params.scala
+++ b/cask/src/cask/endpoints/Params.scala
@@ -5,20 +5,19 @@ import cask.endpoints.ParamReader.NilParam
 
 class Subpath(val value: Seq[String])
 object Subpath{
-  implicit object SubpathParam extends NilParam[Subpath](ctx => new Subpath(ctx.remaining))
+  implicit object SubpathParam extends NilParam[Subpath]((ctx, label) => new Subpath(ctx.remaining))
 
 }
 class Cookies(val value: Map[String, Cookie])
 object Cookies{
-  implicit object CookieParam extends NilParam[Cookies](ctx => {
+  implicit object CookieParam extends NilParam[Cookies]((ctx, label) => {
     import collection.JavaConverters._
     new Cookies(ctx.exchange.getRequestCookies.asScala.toMap.map{case (k, v) => (k, Cookie.fromUndertow(v))})
   })
 }
 object CookieParam{
-  implicit object SubpathParamParam extends NilParam[CookieParam](ctx =>
-//    new CookieParam(ctx.exchange.getRequestCookies())
-    ???
+  implicit object CookieParamParam extends NilParam[CookieParam]((ctx, label) =>
+    new CookieParam(Cookie.fromUndertow(ctx.exchange.getRequestCookies().get(label)))
   )
 }
 
diff --git a/cask/src/cask/endpoints/WebEndpoints.scala b/cask/src/cask/endpoints/WebEndpoints.scala
index ddef543..e2f7b67 100644
--- a/cask/src/cask/endpoints/WebEndpoints.scala
+++ b/cask/src/cask/endpoints/WebEndpoints.scala
@@ -35,12 +35,12 @@ class route(val path: String, val methods: Seq[String], override val subpath: Bo
 abstract class QueryParamReader[T]
   extends Router.ArgReader[Seq[String], T, cask.model.ParamContext]{
   def arity: Int
-  def read(ctx: cask.model.ParamContext, v: Seq[String]): T
+  def read(ctx: cask.model.ParamContext, label: String, v: Seq[String]): T
 }
 object QueryParamReader{
   class SimpleParam[T](f: String => T) extends QueryParamReader[T]{
     def arity = 1
-    def read(ctx: cask.model.ParamContext, v: Seq[String]): T = f(v.head)
+    def read(ctx: cask.model.ParamContext, label: String, v: Seq[String]): T = f(v.head)
   }
 
   implicit object StringParam extends SimpleParam[String](x => x)
@@ -53,15 +53,15 @@ object QueryParamReader{
   implicit object FloatParam extends SimpleParam[Float](_.toFloat)
   implicit def SeqParam[T: QueryParamReader] = new QueryParamReader[Seq[T]]{
     def arity = 1
-    def read(ctx: cask.model.ParamContext, v: Seq[String]): Seq[T] = {
-      v.map(x => implicitly[QueryParamReader[T]].read(ctx, Seq(x)))
+    def read(ctx: cask.model.ParamContext, label: String, v: Seq[String]): Seq[T] = {
+      v.map(x => implicitly[QueryParamReader[T]].read(ctx, label, Seq(x)))
     }
   }
   implicit def paramReader[T: ParamReader] = new QueryParamReader[T] {
     override def arity = 0
 
-    override def read(ctx: cask.model.ParamContext, v: Seq[String]) = {
-      implicitly[ParamReader[T]].read(ctx, v)
+    override def read(ctx: cask.model.ParamContext, label: String, v: Seq[String]) = {
+      implicitly[ParamReader[T]].read(ctx, label, v)
     }
   }
 
diff --git a/cask/src/cask/internal/Router.scala b/cask/src/cask/internal/Router.scala
index f6a4405..aa2954a 100644
--- a/cask/src/cask/internal/Router.scala
+++ b/cask/src/cask/internal/Router.scala
@@ -32,7 +32,7 @@ object Router{
 
   trait ArgReader[I, +T, -C]{
     def arity: Int
-    def read(ctx: C, input: I): T
+    def read(ctx: C, label: String, input: I): T
   }
 
   def stripDashes(s: String) = {
@@ -66,22 +66,21 @@ object Router{
     catch{ case e: Throwable => Left(error(e))}
   }
 
-  def read[I, C]
-  (dict: Map[String, I],
-   default: => Option[Any],
-   arg: ArgSig[I, _, _, C],
-   thunk: I => Any): FailMaybe = {
+  def read[I, C](dict: Map[String, I],
+                 default: => Option[Any],
+                 arg: ArgSig[I, _, _, C],
+                 thunk: (String, I) => Any): FailMaybe = {
     arg.reads.arity match{
       case 0 =>
         tryEither(
-          thunk(null.asInstanceOf[I]), Result.ParamError.DefaultFailed(arg, _)).left.map(Seq(_))
+          thunk(arg.name, null.asInstanceOf[I]), Result.ParamError.DefaultFailed(arg, _)).left.map(Seq(_))
       case 1 =>
         dict.get(arg.name) match{
           case None =>
             tryEither(default.get, Result.ParamError.DefaultFailed(arg, _)).left.map(Seq(_))
 
           case Some(x) =>
-            tryEither(thunk(x), Result.ParamError.Invalid(arg, x, _)).left.map(Seq(_))
+            tryEither(thunk(arg.name, x), Result.ParamError.Invalid(arg, x, _)).left.map(Seq(_))
         }
     }
 
@@ -159,12 +158,11 @@ object Router{
     }
   }
 
-  def makeReadCall[I, C]
-  (dict: Map[String, I],
-   ctx: C,
-   default: => Option[Any],
-   arg: ArgSig[I, _, _, C]) = {
-    read[I, C](dict, default, arg, arg.reads.read(ctx, _))
+  def makeReadCall[I, C](dict: Map[String, I],
+                         ctx: C,
+                         default: => Option[Any],
+                         arg: ArgSig[I, _, _, C]) = {
+    read[I, C](dict, default, arg, arg.reads.read(ctx, _, _))
   }
 
 }