Better responseAs mapping, done on the client thread pool

3 files changed, 28 insertions, 40 deletions

diff --git a/core/src/main/scala/com/softwaremill/sttp/HttpURLConnectionSttpHandler.scala b/core/src/main/scala/com/softwaremill/sttp/HttpURLConnectionSttpHandler.scala
index f5a5971..1ef7fc2 100644
--- a/core/src/main/scala/com/softwaremill/sttp/HttpURLConnectionSttpHandler.scala
+++ b/core/src/main/scala/com/softwaremill/sttp/HttpURLConnectionSttpHandler.scala
@@ -101,15 +101,16 @@ object HttpURLConnectionSttpHandler extends SttpHandler[Id, Nothing] {
     def asString(enc: String) = Source.fromInputStream(is, enc).mkString
 
     responseAs match {
-      case IgnoreResponse(g) =>
-        @tailrec def consume(): Unit = if (is.read() != -1) consume()
+      case MappedResponseAs(raw, g) => g(readResponseBody(is, raw))
 
-        g(consume())
+      case IgnoreResponse =>
+        @tailrec def consume(): Unit = if (is.read() != -1) consume()
+        consume()
 
-      case ResponseAsString(enc, g) =>
-        g(asString(enc))
+      case ResponseAsString(enc) =>
+        asString(enc)
 
-      case ResponseAsByteArray(g) =>
+      case ResponseAsByteArray =>
         val os = new ByteArrayOutputStream
         var read = 0
         val buf = new Array[Byte](1024)
@@ -125,12 +126,12 @@ object HttpURLConnectionSttpHandler extends SttpHandler[Id, Nothing] {
 
         transfer()
 
-        g(os.toByteArray)
+        os.toByteArray
 
-      case r @ ResponseAsParams(enc, g) =>
-        g(r.parse(asString(enc)))
+      case r @ ResponseAsParams(enc) =>
+        r.parse(asString(enc))
 
-      case ResponseAsStream(_) =>
+      case ResponseAsStream() =>
         // only possible when the user requests the response as a stream of
         // Nothing. Oh well ...
         throw new IllegalStateException()
diff --git a/core/src/main/scala/com/softwaremill/sttp/model/package.scala b/core/src/main/scala/com/softwaremill/sttp/model/package.scala
index def6132..e0b4048 100644
--- a/core/src/main/scala/com/softwaremill/sttp/model/package.scala
+++ b/core/src/main/scala/com/softwaremill/sttp/model/package.scala
@@ -47,29 +47,16 @@ package object model {
     * @tparam S If `T` is a stream, the type of the stream. Otherwise, `Nothing`.
     */
   sealed trait ResponseAs[T, +S] {
-    def map[T2](f: T => T2): ResponseAs[T2, S]
+    def map[T2](f: T => T2): ResponseAs[T2, S] =
+      MappedResponseAs[T, T2, S](this, f)
   }
 
-  case class IgnoreResponse[T](g: Unit => T) extends ResponseAs[T, Nothing] {
-    override def map[T2](f: T => T2): ResponseAs[T2, Nothing] =
-      IgnoreResponse(g andThen f)
-  }
-  case class ResponseAsString[T](encoding: String, g: String => T)
-      extends ResponseAs[T, Nothing] {
-    override def map[T2](f: T => T2): ResponseAs[T2, Nothing] =
-      ResponseAsString(encoding, g andThen f)
-  }
-  case class ResponseAsByteArray[T](g: Array[Byte] => T)
-      extends ResponseAs[T, Nothing] {
-    override def map[T2](f: T => T2): ResponseAs[T2, Nothing] =
-      ResponseAsByteArray(g andThen f)
-  }
-  case class ResponseAsParams[T](encoding: String,
-                                 g: Seq[(String, String)] => T)
-      extends ResponseAs[T, Nothing] {
-
-    override def map[T2](f: T => T2): ResponseAs[T2, Nothing] =
-      ResponseAsParams(encoding, g andThen f)
+  case object IgnoreResponse extends ResponseAs[Unit, Nothing]
+  case class ResponseAsString(encoding: String)
+      extends ResponseAs[String, Nothing]
+  case object ResponseAsByteArray extends ResponseAs[Array[Byte], Nothing]
+  case class ResponseAsParams(encoding: String)
+      extends ResponseAs[Seq[(String, String)], Nothing] {
 
     private[sttp] def parse(s: String): Seq[(String, String)] = {
       s.split("&")
@@ -84,11 +71,11 @@ package object model {
         })
     }
   }
-  case class ResponseAsStream[T, T2, S](g: T => T2)(
-      implicit val responseIsStream: S =:= T)
+  case class ResponseAsStream[T, S]()(implicit val responseIsStream: S =:= T)
+      extends ResponseAs[T, S]
+  case class MappedResponseAs[T, T2, S](raw: ResponseAs[T, S], g: T => T2)
       extends ResponseAs[T2, S] {
-
     override def map[T3](f: T2 => T3): ResponseAs[T3, S] =
-      ResponseAsStream(g andThen f)
+      MappedResponseAs[T, T3, S](raw, g andThen f)
   }
 }
diff --git a/core/src/main/scala/com/softwaremill/sttp/package.scala b/core/src/main/scala/com/softwaremill/sttp/package.scala
index aa2224a..f9ee9c6 100644
--- a/core/src/main/scala/com/softwaremill/sttp/package.scala
+++ b/core/src/main/scala/com/softwaremill/sttp/package.scala
@@ -16,16 +16,16 @@ package object sttp {
   type Id[X] = X
   type Empty[X] = None.type
 
-  def ignore: ResponseAs[Unit, Nothing] = IgnoreResponse(identity)
+  def ignore: ResponseAs[Unit, Nothing] = IgnoreResponse
 
   /**
     * Uses `utf-8` encoding.
     */
   def asString: ResponseAs[String, Nothing] = asString(Utf8)
   def asString(encoding: String): ResponseAs[String, Nothing] =
-    ResponseAsString(encoding, identity)
+    ResponseAsString(encoding)
   def asByteArray: ResponseAs[Array[Byte], Nothing] =
-    ResponseAsByteArray(identity)
+    ResponseAsByteArray
 
   /**
     * Uses `utf-8` encoding.
@@ -33,9 +33,9 @@ package object sttp {
   def asParams: ResponseAs[Seq[(String, String)], Nothing] =
     asParams(Utf8)
   def asParams(encoding: String): ResponseAs[Seq[(String, String)], Nothing] =
-    ResponseAsParams(encoding, identity)
+    ResponseAsParams(encoding)
 
-  def asStream[S]: ResponseAs[S, S] = ResponseAsStream[S, S, S](identity)
+  def asStream[S]: ResponseAs[S, S] = ResponseAsStream[S, S]()
 
   /**
     * Use the factory methods `multiPart` to conveniently create instances of