content encoding - q param parser

Author: Eun Woo Song

src/main/scala/com/lascala/http/Header.scala

@@ -0,0 +1,106 @@
+/*
+ * This software is licensed under the Apache 2 license, quoted below.
+ *
+ *  Copyright 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.lascala.http
+
+case class Header(name: String, value: String)
+
+object Header {
+  final val ACCEPT                           = "Accept";
+  final val ACCEPT_CHARSET                   = "Accept-Charset";
+  final val ACCEPT_ENCODING                  = "Accept-Encoding";
+  final val ACCEPT_LANGUAGE                  = "Accept-Language";
+  final val ACCEPT_RANGES                    = "Accept-Ranges";
+  final val AGE                              = "Age";
+  final val ALLOW                            = "Allow";
+  final val AUTHORIZATION                    = "Authorization";
+  final val CACHE_CONTROL                    = "Cache-Control";
+  final val CONNECTION                       = "Connection";
+  final val CONTENT_ENCODING                 = "Content-Encoding";
+  final val CONTENT_LANGUAGE                 = "Content-Language";
+  final val CONTENT_LENGTH                   = "Content-Length";
+  final val CONTENT_LOCATION                 = "Content-Location";
+  final val CONTENT_MD5                      = "Content-MD5";
+  final val CONTENT_RANGE                    = "Content-Range";
+  final val CONTENT_TRANSFER_ENCODING        = "Content-Transfer-Encoding";
+  final val CONTENT_TYPE                     = "Content-Type";
+  final val COOKIE                           = "Cookie";
+  final val DATE                             = "Date";
+  final val ETAG                             = "Etag";
+  final val EXPECT                           = "Expect";
+  final val EXPIRES                          = "Expires";
+  final val FROM                             = "From";
+  final val HOST                             = "Host";
+  final val IF_MATCH                         = "If-Match";
+  final val IF_MODIFIED_SINCE                = "If-Modified-Since";
+  final val IF_NONE_MATCH                    = "If-None-Match";
+  final val IF_RANGE                         = "If-Range";
+  final val IF_UNMODIFIED_SINCE              = "If-Unmodified-Since";
+  final val LAST_MODIFIED                    = "Last-Modified";
+  final val LOCATION                         = "Location";
+  final val MAX_FORWARDS                     = "Max-Forwards";
+  final val PRAGMA                           = "Pragma";
+  final val PROXY_AUTHENTICATE               = "Proxy-Authenticate";
+  final val PROXY_AUTHORIZATION              = "Proxy-Authorization";
+  final val RANGE                            = "Range";
+  final val REFERER                          = "Referer";
+  final val RETRY_AFTER                      = "Retry-After";
+  final val SERVER                           = "Server";
+  final val SET_COOKIE                       = "Set-Cookie";
+  final val SET_COOKIE2                      = "Set-Cookie2";
+  final val TE                               = "Te";
+  final val TRAILER                          = "Trailer";
+  final val TRANSFER_ENCODING                = "Transfer-Encoding";
+  final val UPGRADE                          = "Upgrade";
+  final val USER_AGENT                       = "User-Agent";
+  final val VARY                             = "Vary";
+  final val VIA                              = "Via";
+  final val WARNING                          = "Warning";
+  final val WWW_AUTHENTICATE                 = "WWW-Authenticate";
+  final val ACCESS_CONTROL_ALLOW_ORIGIN      = "Access-Control-Allow-Origin";
+  final val ACCESS_CONTROL_EXPOSE_HEADERS    = "Access-Control-Expose-Headers";
+  final val ACCESS_CONTROL_MAX_AGE           = "Access-Control-Max-Age";
+  final val ACCESS_CONTROL_ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
+  final val ACCESS_CONTROL_ALLOW_METHODS     = "Access-Control-Allow-Methods";
+  final val ACCESS_CONTROL_ALLOW_HEADERS     = "Access-Control-Allow-Headers";
+  final val ORIGIN                           = "Origin";
+  final val ACCESS_CONTROL_REQUEST_METHOD    = "Access-Control-Request-Method";
+  final val ACCESS_CONTROL_REQUEST_HEADERS   = "Access-Control-Request-Headers";
+}
+
+case class Headers(headers: List[Header]) {
+  def get(name: String): Option[Header]  = headers.find(_.name.toLowerCase == name.toLowerCase)
+  def topContentEncoding: Option[String] = get(Header.CONTENT_ENCODING).flatMap(Headers.parseQparameters(_).headOption).map(_.value)
+  def contentEncodings: Seq[String]      = get(Header.CONTENT_ENCODING).map(Headers.parseQparameters(_).map(_.value)).getOrElse(Seq.empty[String])
+}
+
+object Headers {
+  private final val VALUE_SEPARATOR   = ","
+  private final val Q_PARAM_SEPARATOR = ";"
+  private final val Q_PARAM           = "q="
+
+  case class QParamHeader(value: String, qParam: Double)
+
+  def parseQparameters(header: Header) = header.value.split(VALUE_SEPARATOR).toSeq.map{
+    _.split(Q_PARAM_SEPARATOR) match {
+      case Array(value, qParam) =>
+        val qRate = if(qParam.contains(Q_PARAM)) qParam.split(Q_PARAM).last.toDouble else 1.0
+        QParamHeader(value.trim, qRate)
+      case Array(value) => QParamHeader(value.trim, 1.0)
+    }
+  }.sortWith(_.qParam > _.qParam)
+}

src/main/scala/com/lascala/http/HttpConstants.scala

@@ -1,3 +1,20 @@
+/*
+ * This software is licensed under the Apache 2 license, quoted below.
+ *
+ *  Copyright 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
 package com.lascala.http
 
 import akka.util.ByteString

src/main/scala/com/lascala/http/request/HttpRequest.scala

@@ -18,6 +18,7 @@
 package com.lascala.http.request
 
 import akka.util.ByteString
+import com.lascala.http.Headers
 
 /**
  * http request 객체 및
@@ -30,27 +31,3 @@ case class HttpRequest(
   httpver: String,
   headers: Headers,
   body: Option[ByteString])
-
-case class Header(name: String, value: String)
-
-object Header {
-  val VALUE_SEPARATOR   = ","
-  val Q_PARAM_SEPARATOR = ";"
-  val Q_PARAM           = "q="
-
-  case class QParamHeader(value: String, qParam: Double)
-
-  def parseQparameters(header: Header) = header.value.split(VALUE_SEPARATOR).toSeq.map{
-    _ match {
-      case h if h contains(Q_PARAM_SEPARATOR) =>
-        val Array(value, qParam) = h.split(Q_PARAM_SEPARATOR)
-        val qRate = if(qParam.contains("q=")) qParam.split("q=").last.toDouble else 1.0
-        QParamHeader(value.trim, qRate)
-      case h => QParamHeader(h.trim, 1.0)
-    }
-  }.sortWith(_.qParam > _.qParam)
-}
-
-case class Headers(headers: List[Header]) {
-  def get(name: String) = headers.find(_.name.toLowerCase == name.toLowerCase)
-}

src/main/scala/com/lascala/http/response/OKResponse.scala

@@ -24,16 +24,18 @@ import java.io.File
 import java.util.Date
 import org.apache.tika.Tika
 
-case class OKResponse(body: ByteString = ByteString.empty, shouldKeepAlive: Boolean = true,
-                      mimeType: String = "text/html",      lastModified: Date       = null,
-                      etag: ByteString = null) extends HttpResponse {
+case class OKResponse(body: ByteString         = ByteString.empty,
+                      shouldKeepAlive: Boolean = true,
+                      mimeType: String         = "text/html",
+                      lastModified: Date       = null,
+                      etag: ByteString         = null) extends HttpResponse {
   val status = ByteString("200")
   val reason = ByteString("OK")
 
   def withMimeType(mimeType: String) = this match {
-    // In case of ChunkedEncodable, need to manually instantiate a new OKResponse with ChunkedEncodable 
+    // In case of ChunkedEncodable, need to manually instantiate a new OKResponse with ChunkedEncodable
     // Instead of just using copy method in order to preserve the ChunkedEncodable type.
-    case t: ChunkedEncodable => 
+    case t: ChunkedEncodable =>
       new OKResponse(this.body, this.shouldKeepAlive, mimeType) with ChunkedEncodable {
         def chunkedData: Enumerator[ByteString] = t.chunkedData
       }
@@ -43,15 +45,15 @@ case class OKResponse(body: ByteString = ByteString.empty, shouldKeepAlive: Bool
 
 object OKResponse {
 
-  def stream(chunk: Enumerator[ByteString]) = 
+  def stream(chunk: Enumerator[ByteString]) =
     new OKResponse(body = ByteString.empty, mimeType = "text/html") with ChunkedEncodable {
       def chunkedData: Enumerator[ByteString] = chunk
     }
 
   def fromFile(file: File) = new OKResponse(
-    body = HttpResponse.readFile(file),
+    body            = HttpResponse.readFile(file),
     shouldKeepAlive = true,
-    mimeType = new Tika().detect(file),
-    lastModified = new Date(file.lastModified),
-    etag = ByteString(HttpResponse.computeETag(file)))
+    mimeType        = new Tika().detect(file),
+    lastModified    = new Date(file.lastModified),
+    etag            = ByteString(HttpResponse.computeETag(file)))
 }

src/main/scala/com/lascala/http/server/HttpIteratees.scala

@@ -19,8 +19,8 @@ package com.lascala.http.server
 
 import akka.actor._
 import akka.util.ByteString
-import com.lascala.http.HttpConstants
-import com.lascala.http.request.{Header, Headers, HttpRequest}
+import com.lascala.http.{Header, Headers, HttpConstants}
+import com.lascala.http.request.HttpRequest
 
 /**
  * iteratee: http://www.haskell.org/haskellwiki/Iteratee_I/O
@@ -33,9 +33,12 @@ object HttpIteratees {
     for {
       requestLine <- readRequestLine
       (meth, (path, query), httpver) = requestLine
-      eheaders <- readHeaders
+      headers <- readHeaders
       body <- readBody(headers)
-    } yield HttpRequest(meth, path, query, httpver, Headers(headers), body)
+    } yield {
+
+      HttpRequest(meth, path, query, httpver, Headers(headers), body)
+    }
 	}
 
 	def ascii(bytes: ByteString): String = bytes.decodeString("US-ASCII").trim

src/main/scala/common/main.scala

@@ -27,7 +27,7 @@ import com.lascala.http._
 import com.lascala.http.HttpResponse._
 import java.io.File
 import com.lascala.libs.Enumerator
-import request.{HttpRequest, Header, Headers}
+import request.HttpRequest
 import response.error.{MethodNotAllowedError, NotFoundError}
 import response.OKResponse
 import response.other.NotModifiedResponse

src/test/scala/com/lascala/http/request/HeaderTest.scala renamed to src/test/scala/com/lascala/http/HeadersTest.scala

@@ -15,15 +15,16 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.lascala.http.request
+package com.lascala.http
 
 import org.scalatest._
 import org.scalatest.matchers._
-import Header.QParamHeader
+import com.lascala.http.Headers.QParamHeader
 
-class HeaderTest extends FlatSpec with ShouldMatchers {
-  "Header" can "process Content-Encoding header with q parameters correctly" in {
-    val res = Header.parseQparameters(Header("Content-Encoding","gzip; q=0.7, deflate; q=0.8, test; q=1.000, test2; q=0.000"))
+class HeadersTest extends FlatSpec with ShouldMatchers {
+
+  "Headers" can "process Content-Encoding header with q parameters correctly" in {
+    val res = Headers.parseQparameters(Header("Content-Encoding","gzip; q=0.7, deflate; q=0.8, test; q=1.000, test2; q=0.000"))
     val expectedQParamHeaders = Seq(
       QParamHeader("test", 1.000),
       QParamHeader("deflate", 0.8),
@@ -34,7 +35,7 @@ class HeaderTest extends FlatSpec with ShouldMatchers {
   }
 
   it can "process Content-Encoding header WITHOUT q parameters correctly" in {
-    val res = Header.parseQparameters(Header("Content-Encoding","gzip, deflate, test, test2"))
+    val res = Headers.parseQparameters(Header("Content-Encoding","gzip, deflate, test, test2"))
     val expectedQParamHeaders = Seq(
       QParamHeader("gzip", 1.0),
       QParamHeader("deflate", 1.0),
@@ -45,7 +46,7 @@ class HeaderTest extends FlatSpec with ShouldMatchers {
   }
 
   it can "process Content-Encoding header with values that may or may not have q values" in {
-    val res = Header.parseQparameters(Header("Content-Encoding","gzip; q=0.7, deflate, test; q=0.5, test2"))
+    val res = Headers.parseQparameters(Header("Content-Encoding","gzip; q=0.7, deflate, test; q=0.5, test2"))
 
     val expectedQParamHeaders = Seq(
       QParamHeader("deflate", 1.0),
@@ -55,4 +56,25 @@ class HeaderTest extends FlatSpec with ShouldMatchers {
 
     res should be (expectedQParamHeaders)
   }
+
+  it can "retrieve the highest priority content encoding based on q parameter" in {
+    val headers = List(
+      Header(Header.ACCEPT_CHARSET, "Accept-Charset: utf-8"),
+      Header(Header.CONTENT_ENCODING, "gzip; q=0.7, deflate, test; q=0.5, test2"),
+      Header(Header.ACCEPT, "Accept: text/plain")
+    )
+
+    Headers(headers).topContentEncoding should be (Some("deflate"))
+  }
+
+  it can "retrieve content encodings in priority order based on q parameter" in {
+    val headers = List(
+        Header(Header.ACCEPT_CHARSET, "Accept-Charset: utf-8"),
+        Header(Header.CONTENT_ENCODING, "gzip; q=0.7, deflate, test; q=0.5, test2"),
+        Header(Header.ACCEPT, "Accept: text/plain")
+    )
+
+    Headers(headers).contentEncodings should not be (Seq("test2", "test", "gzip", "deflate"))
+    Headers(headers).contentEncodings should be (Seq("deflate", "test2", "gzip", "test"))
+  }
 }