case insensitive header names in REST framework

Author: ghik

commons-core/src/main/scala/com/avsystem/commons/meta/Mapping.scala

@@ -1,6 +1,8 @@
 package com.avsystem.commons
 package meta
 
+import java.util.Locale
+
 import com.avsystem.commons.meta.Mapping.{ConcatIterable, KeyFilteredIterable}
 import com.avsystem.commons.serialization.GenCodec
 
@@ -11,20 +13,25 @@ import scala.collection.{MapLike, mutable}
   * Simple immutable structure to collect named values while retaining their order and
   * providing fast, hashed lookup by name when necessary.
   * Intended to be used for [[multi]] raw parameters.
+  * When `caseInsensitive = true`, fetching values by name will be case-insensitive, i.e. keys in internal
+  * hashmap and those passed to `contains`, `isDefinedAt`, `apply` and `applyOrElse` will be lowercased.
   */
-final class Mapping[+V](private val wrapped: IIterable[(String, V)])
+final class Mapping[+V](private val wrapped: IIterable[(String, V)], caseInsensitive: Boolean = false)
   extends IMap[String, V] with MapLike[String, V, Mapping[V]] {
 
+  private def normKey(key: String): String =
+    if (caseInsensitive) key.toLowerCase(Locale.ENGLISH) else key
+
   private[this] lazy val vector = {
     val keys = new mutable.HashSet[String]
-    wrapped.iterator.filter({ case (k, _) => keys.add(k) }).toVector
+    wrapped.iterator.filter({ case (k, _) => keys.add(normKey(k)) }).toVector
   }
   private[this] lazy val map =
-    wrapped.toMap
+    wrapped.iterator.map({ case (k, v) => (normKey(k), v) }).toMap
 
   override def empty: Mapping[V] = Mapping.empty
   override protected[this] def newBuilder: mutable.Builder[(String, V), Mapping[V]] =
-    Mapping.newBuilder[V]
+    Mapping.newBuilder[V]()
 
   override def size: Int =
     vector.size
@@ -33,17 +40,18 @@ final class Mapping[+V](private val wrapped: IIterable[(String, V)])
   override def valuesIterator: Iterator[V] =
     vector.iterator.map({ case (_, v) => v })
   override def keys: Iterable[String] =
-    map.keys
+    vector.map({ case (k, _) => k })
   override def keySet: ISet[String] =
-    map.keySet
+    vector.iterator.map({ case (k, _) => k }).toSet
   override def contains(key: String): Boolean =
-    map.contains(key)
+    map.contains(normKey(key))
   override def isDefinedAt(key: String): Boolean =
-    map.isDefinedAt(key)
+    map.isDefinedAt(normKey(key))
   override def applyOrElse[A1 <: String, B1 >: V](key: A1, default: A1 => B1): B1 =
-    map.applyOrElse(key, default)
+    if (!caseInsensitive) map.applyOrElse(key, default)
+    else map.applyOrElse(normKey(key), (_: String) => default(key))
   override def apply(key: String): V =
-    map.apply(key)
+    map.apply(normKey(key))
 
   def get(key: String): Option[V] = map.get(key)
   def -(key: String): Mapping[V] = Mapping(new KeyFilteredIterable(wrapped, _ == key))
@@ -65,10 +73,11 @@ final class Mapping[+V](private val wrapped: IIterable[(String, V)])
 object Mapping {
   def empty[V]: Mapping[V] = new Mapping(Nil)
   def apply[V](pairs: (String, V)*): Mapping[V] = new Mapping(pairs.toList)
-  def apply[V](pairs: IIterable[(String, V)]): Mapping[V] = new Mapping(pairs)
+  def apply[V](pairs: IIterable[(String, V)], caseInsensitive: Boolean = false): Mapping[V] =
+    new Mapping(pairs, caseInsensitive)
 
-  def newBuilder[V]: mutable.Builder[(String, V), Mapping[V]] =
-    new MListBuffer[(String, V)].mapResult(new Mapping(_))
+  def newBuilder[V](caseInsensitive: Boolean = false): mutable.Builder[(String, V), Mapping[V]] =
+    new MListBuffer[(String, V)].mapResult(new Mapping(_, caseInsensitive))
 
   private class ConcatIterable[+V](first: IIterable[V], second: IIterable[V]) extends IIterable[V] {
     def iterator: Iterator[V] = first.iterator ++ second.iterator
@@ -82,8 +91,8 @@ object Mapping {
   }
 
   private val reusableCBF = new CanBuildFrom[Nothing, (String, Any), Mapping[Any]] {
-    def apply(from: Nothing): mutable.Builder[(String, Any), Mapping[Any]] = newBuilder[Any]
-    def apply(): mutable.Builder[(String, Any), Mapping[Any]] = newBuilder[Any]
+    def apply(from: Nothing): mutable.Builder[(String, Any), Mapping[Any]] = newBuilder[Any]()
+    def apply(): mutable.Builder[(String, Any), Mapping[Any]] = newBuilder[Any]()
   }
 
   implicit def canBuildFrom[V]: CanBuildFrom[Nothing, (String, V), Mapping[V]] =

commons-core/src/main/scala/com/avsystem/commons/rest/data.scala

@@ -49,7 +49,7 @@ object QueryValue {
     }.mkString(FormKVPairSep)
 
   def decode(queryString: String): Mapping[QueryValue] = {
-    val builder = Mapping.newBuilder[QueryValue]
+    val builder = Mapping.newBuilder[QueryValue]()
     queryString.split(FormKVPairSep).iterator.filter(_.nonEmpty).map(_.split(FormKVSep, 2)).foreach {
       case Array(name, value) => builder += UrlEncoding.decode(name) -> QueryValue(UrlEncoding.decode(value))
       case _ => throw new IllegalArgumentException(s"invalid query string $queryString")
@@ -166,7 +166,7 @@ object HttpBody {
     case HttpBody.Empty => Mapping.empty
     case _ =>
       val oi = new JsonStringInput(new JsonReader(body.readJson().value)).readObject()
-      val builder = Mapping.newBuilder[JsonValue]
+      val builder = Mapping.newBuilder[JsonValue]()
       while (oi.hasNext) {
         val fi = oi.nextField()
         builder += ((fi.fieldName, JsonValue(fi.readRawJson())))

commons-core/src/test/scala/com/avsystem/commons/rest/RawRestTest.scala

@@ -35,6 +35,8 @@ trait UserApi {
   def autopost(bodyarg: String): Future[String]
   def singleBodyAutopost(@Body body: String): Future[String]
   @FormBody def formpost(@Query qarg: String, sarg: String, iarg: Int): Future[String]
+
+  def eatHeader(@Header("X-Stuff") stuff: String): Future[String]
 }
 object UserApi extends DefaultRestApiCompanion[UserApi]
 
@@ -77,6 +79,7 @@ class RawRestTest extends FunSuite with ScalaFutures {
     def formpost(qarg: String, sarg: String, iarg: Int): Future[String] = Future.successful(s"$qarg-$sarg-$iarg")
     def fail: Future[Unit] = Future.failed(HttpErrorException(400, "zuo"))
     def failMore: Future[Unit] = throw HttpErrorException(400, "ZUO")
+    def eatHeader(stuff: String): Future[String] = Future.successful(stuff.toLowerCase)
   }
 
   var trafficLog: String = _
@@ -198,4 +201,16 @@ class RawRestTest extends FunSuite with ScalaFutures {
     serverHandle(request).apply(promise.complete)
     assert(promise.future.futureValue == response)
   }
+
+  test("header case insensitivity") {
+    val params = RestParameters(
+      path = List(PathValue("eatHeader")),
+      headers = Mapping(List("x-sTuFf" -> HeaderValue("StUfF")), caseInsensitive = true)
+    )
+    val request = RestRequest(HttpMethod.POST, params, HttpBody.Empty)
+    val response = RestResponse(200, Mapping.empty, HttpBody.json(JsonValue("\"stuff\"")))
+    val promise = Promise[RestResponse]
+    serverHandle(request).apply(promise.complete)
+    assert(promise.future.futureValue == response)
+  }
 }

commons-jetty/src/main/scala/com/avsystem/commons/jetty/rest/RestServlet.scala

@@ -30,7 +30,7 @@ object RestServlet {
     val pathPrefix = request.getContextPath.orEmpty + request.getServletPath.orEmpty
     val path = PathValue.splitDecode(request.getRequestURI.stripPrefix(pathPrefix))
     val query = request.getQueryString.opt.map(QueryValue.decode).getOrElse(Mapping.empty)
-    val headersBuilder = Mapping.newBuilder[HeaderValue]
+    val headersBuilder = Mapping.newBuilder[HeaderValue](caseInsensitive = true)
     request.getHeaderNames.asScala.foreach { headerName =>
       headersBuilder += headerName -> HeaderValue(request.getHeader(headerName))
     }