First workaround to use RosHTTP Client

Author: juanpedromoreno

build.sbt

@@ -34,13 +34,13 @@ lazy val `evaluator-client` = (crossProject in file("client"))
       "io.circe" %% "circe-generic" % v('circe),
       "io.circe" %% "circe-parser" % v('circe),
       "org.log4s" %% "log4s" % v('log4s),
-      "org.scalaj" %% "scalaj-http" % v('scalajhttp),
       "org.slf4j" % "slf4j-simple" % v('slf4j),
       // Testing libraries
       "org.scalatest" %% "scalatest" % v('scalaTest) % "test"
     )
-    }
-  )
+    },
+    libraryDependencies += "fr.hmil" %%% "roshttp" % "1.1.0"
+)
   .jsSettings(scalaJSSettings: _*)
 
 lazy val `evaluator-client-jvm` = `evaluator-client`.jvm
@@ -75,4 +75,4 @@ lazy val `evaluator-server` = (project in file("server"))
   .settings(compilerDependencySettings: _*)
 
 onLoad in Global := (Command.process("project evaluator-server", _: State)) compose (onLoad in Global).value
-addCommandAlias("publishSignedAll", ";evaluator-shared/publishSigned;evaluator-client/publishSigned")
+addCommandAlias("publishSignedAll", ";evaluator-sharedJS/publishSigned;evaluator-sharedJVM/publishSigned;evaluator-clientJS/publishSigned;evaluator-clientJVM/publishSigned")

client/shared/src/main/scala/org/scalaexercises/evaluator/EvaluatorAPI.scala

@@ -7,24 +7,13 @@ package org.scalaexercises.evaluator
 
 import cats.free.Free
 import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
-import org.scalaexercises.evaluator.free.algebra.{EvaluatorOp, EvaluatorOps}
+import org.scalaexercises.evaluator.free.algebra.EvaluatorOps
 
-import scala.concurrent.duration.Duration
-
-class EvaluatorAPI[F[_]](url: String,
-                         authKey: String,
-                         connTimeout: Duration,
-                         readTimeout: Duration)(implicit O: EvaluatorOps[F]) {
+class EvaluatorAPI[F[_]](url: String, authKey: String)(
+  implicit O: EvaluatorOps[F]) {
 
   def evaluates(resolvers: List[String] = Nil,
                 dependencies: List[Dependency] = Nil,
                 code: String): Free[F, EvaluationResponse[EvalResponse]] =
-    O.evaluates(
-      url,
-      authKey,
-      connTimeout,
-      readTimeout,
-      resolvers,
-      dependencies,
-      code)
+    O.evaluates(url, authKey, resolvers, dependencies, code)
 }

client/shared/src/main/scala/org/scalaexercises/evaluator/EvaluatorClient.scala

@@ -6,36 +6,30 @@
 package org.scalaexercises.evaluator
 
 import cats.data.XorT
-import cats.{MonadError, ~>}
+import cats.~>
+import cats._, cats.std.all._
 import org.scalaexercises.evaluator.EvaluatorResponses.{EvalIO, EvaluationException, EvaluationResponse, EvaluationResult}
 import org.scalaexercises.evaluator.free.algebra.EvaluatorOp
 
-import scala.concurrent.duration._
-import scala.concurrent.duration.Duration
+import scala.concurrent.Future
+import scala.concurrent.ExecutionContext.Implicits.global
 
-class EvaluatorClient(url: String,
-                      authKey: String,
-                      connTimeout: Duration = 1.second,
-                      readTimeout: Duration = 10.seconds) {
+class EvaluatorClient(url: String, authKey: String) {
 
-  lazy val api: EvaluatorAPI[EvaluatorOp] =
-    new EvaluatorAPI(url, authKey, connTimeout, readTimeout)
+  lazy val api: EvaluatorAPI[EvaluatorOp] = new EvaluatorAPI(url, authKey)
 
 }
 
 object EvaluatorClient {
 
-  def apply(url: String,
-            authKey: String,
-            connTimeout: Duration = 1.second,
-            readTimeout: Duration = 10.seconds) =
-    new EvaluatorClient(url, authKey, connTimeout, readTimeout)
+  def apply(url: String, authKey: String) =
+    new EvaluatorClient(url, authKey)
 
   implicit class EvaluationIOSyntaxXOR[A](
     evalIO: EvalIO[EvaluationResponse[A]]) {
 
-    def exec[M[_]](implicit I: (EvaluatorOp ~> M),
-                   A: MonadError[M, Throwable]): M[EvaluationResponse[A]] =
+    def exec(
+      implicit I: (EvaluatorOp ~> Future)): Future[EvaluationResponse[A]] =
       evalIO foldMap I
 
     def liftEvaluator: XorT[EvalIO, EvaluationException, EvaluationResult[A]] =

client/shared/src/main/scala/org/scalaexercises/evaluator/EvaluatorResponses.scala

@@ -13,8 +13,11 @@ import io.circe.parser._
 import io.circe.generic.auto._
 import org.scalaexercises.evaluator.free.algebra.EvaluatorOp
 
-import scala.language.higherKinds
-import scalaj.http.HttpResponse
+import scala.concurrent.Future
+import scala.concurrent.ExecutionContext.Implicits.global
+
+import fr.hmil.roshttp.HttpResponse
+import fr.hmil.roshttp.HeaderMap
 
 object EvaluatorResponses {
 
@@ -24,7 +27,7 @@ object EvaluatorResponses {
 
   case class EvaluationResult[A](result: A,
                                  statusCode: Int,
-                                 headers: Map[String, IndexedSeq[String]])
+                                 headers: Map[String, String])
 
   sealed abstract class EvaluationException(msg: String,
                                             cause: Option[Throwable] = None)
@@ -37,24 +40,30 @@ object EvaluatorResponses {
 
   case class UnexpectedException(msg: String) extends EvaluationException(msg)
 
-  def toEntity[A](response: HttpResponse[String])(
-    implicit D: Decoder[A]): EvaluationResponse[A] = response match {
-    case r if r.isSuccess ⇒
-      decode[A](r.body).fold(
-        e ⇒
-          JsonParsingException(e.getMessage, r.body).left[EvaluationResult[A]],
-        result ⇒
-          Xor.Right(EvaluationResult(result, r.code, r.headers.toLowerCase))
-      )
-    case r ⇒
-      UnexpectedException(
-        s"Failed invoking get with status : ${r.code}, body : \n ${r.body}")
-        .left[EvaluationResult[A]]
-  }
+  def toEntity[A](futureResponse: Future[HttpResponse])(
+    implicit D: Decoder[A]): Future[EvaluationResponse[A]] =
+    futureResponse map {
+      case r if isSuccess(r.statusCode) ⇒
+        decode[A](r.body).fold(
+          e ⇒
+            JsonParsingException(e.getMessage, r.body)
+              .left[EvaluationResult[A]],
+          result ⇒
+            Xor.Right(
+              EvaluationResult(result, r.statusCode, r.headers.toLowerCase))
+        )
+      case r ⇒
+        UnexpectedException(
+          s"Failed invoking get with status : ${r.statusCode}, body : \n ${r.body}")
+          .left[EvaluationResult[A]]
+    }
 
-  implicit class HeadersLowerCase[A](headers: Map[String, A]) {
+  private[this] def isSuccess(statusCode: Int) =
+    statusCode >= 200 && statusCode <= 299
 
-    def toLowerCase: Map[String, A] = headers.map(e ⇒ (e._1.toLowerCase, e._2))
+  implicit class HeadersLowerCase[A >: String](headers: HeaderMap[A]) {
 
+    def toLowerCase: Map[String, A] =
+      headers.iterator.map(t => (t._1.toLowerCase, t._2)).toList.toMap
   }
 }

client/shared/src/main/scala/org/scalaexercises/evaluator/api/Evaluator.scala

@@ -11,7 +11,7 @@ import org.scalaexercises.evaluator.http.HttpClient
 import io.circe.generic.auto._
 import io.circe.syntax._
 
-import scala.concurrent.duration.Duration
+import scala.concurrent.Future
 
 class Evaluator {
 
@@ -21,16 +21,12 @@ class Evaluator {
 
   def eval(url: String,
            authKey: String,
-           connTimeout: Duration,
-           readTimeout: Duration,
            resolvers: List[String] = Nil,
            dependencies: List[Dependency] = Nil,
-           code: String): EvaluationResponse[EvalResponse] =
+           code: String): Future[EvaluationResponse[EvalResponse]] =
     httpClient.post[EvalResponse](
       url = url,
       secretKey = authKey,
-      connTimeout = connTimeout,
-      readTimeout = readTimeout,
       data = EvalRequest(resolvers, dependencies, code).asJson.noSpaces)
 
 }

client/shared/src/main/scala/org/scalaexercises/evaluator/free/algebra/EvaluatorOps.scala

@@ -9,14 +9,9 @@ import cats.free.{Free, Inject}
 import org.scalaexercises.evaluator.{Dependency, EvalResponse}
 import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
 
-import scala.concurrent.duration._
-import scala.concurrent.duration.Duration
-
 sealed trait EvaluatorOp[A]
 final case class Evaluates(url: String,
                            authKey: String,
-                           connTimeout: Duration,
-                           readTimeout: Duration,
                            resolvers: List[String] = Nil,
                            dependencies: List[Dependency] = Nil,
                            code: String)
@@ -27,21 +22,12 @@ class EvaluatorOps[F[_]](implicit I: Inject[EvaluatorOp, F]) {
   def evaluates(
     url: String,
     authKey: String,
-    connTimeout: Duration,
-    readTimeout: Duration,
     resolvers: List[String] = Nil,
     dependencies: List[Dependency] = Nil,
     code: String
   ): Free[F, EvaluationResponse[EvalResponse]] =
     Free.inject[EvaluatorOp, F](
-      Evaluates(
-        url,
-        authKey,
-        connTimeout,
-        readTimeout,
-        resolvers,
-        dependencies,
-        code))
+      Evaluates(url, authKey, resolvers, dependencies, code))
 
 }
 

client/shared/src/main/scala/org/scalaexercises/evaluator/free/interpreters/Interpreter.scala

@@ -5,46 +5,25 @@
 
 package org.scalaexercises.evaluator.free.interpreters
 
-import cats.{ApplicativeError, Eval, MonadError, ~>}
+import cats.~>
 import org.scalaexercises.evaluator.api.Evaluator
 import org.scalaexercises.evaluator.free.algebra.{Evaluates, EvaluatorOp}
 
-import scala.language.higherKinds
+import scala.concurrent.Future
 
 trait Interpreter {
 
-  implicit def interpreter[M[_]](
-    implicit A: MonadError[M, Throwable]
-  ): EvaluatorOp ~> M = evaluatorOpsInterpreter[M]
-
   /**
     * Lifts Evaluator Ops to an effect capturing Monad such as Task via natural transformations
     */
-  def evaluatorOpsInterpreter[M[_]](
-    implicit A: ApplicativeError[M, Throwable]): EvaluatorOp ~> M =
-    new (EvaluatorOp ~> M) {
+  implicit def evaluatorOpsInterpreter: EvaluatorOp ~> Future =
+    new (EvaluatorOp ~> Future) {
 
       val evaluator = new Evaluator()
 
-      def apply[A](fa: EvaluatorOp[A]): M[A] = fa match {
-        case Evaluates(
-            url,
-            authKey,
-            connTimeout,
-            readTimeout,
-            resolvers,
-            dependencies,
-            code) ⇒
-          A.pureEval(
-            Eval.later(
-              evaluator.eval(
-                url,
-                authKey,
-                connTimeout,
-                readTimeout,
-                resolvers,
-                dependencies,
-                code)))
+      def apply[A](fa: EvaluatorOp[A]): Future[A] = fa match {
+        case Evaluates(url, authKey, resolvers, dependencies, code) ⇒
+          evaluator.eval(url, authKey, resolvers, dependencies, code)
       }
 
     }

client/shared/src/main/scala/org/scalaexercises/evaluator/http/HttpClient.scala

@@ -8,9 +8,7 @@ package org.scalaexercises.evaluator.http
 import io.circe.Decoder
 import org.scalaexercises.evaluator.EvaluatorResponses
 import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
-
-import scala.concurrent.duration._
-import scala.concurrent.duration.Duration
+import scala.concurrent.Future
 
 object HttpClient {
 
@@ -26,17 +24,11 @@ class HttpClient {
     url: String,
     secretKey: String,
     method: String = "post",
-    connTimeout: Duration,
-    readTimeout: Duration,
     headers: Headers = Map.empty,
     data: String
-  )(implicit D: Decoder[A]): EvaluationResponse[A] =
+  )(implicit D: Decoder[A]): Future[EvaluationResponse[A]] =
     EvaluatorResponses.toEntity(
-      HttpRequestBuilder(
-        url = url,
-        httpVerb = method,
-        connTimeout = connTimeout,
-        readTimeout = readTimeout)
+      HttpRequestBuilder(url = url, httpVerb = method)
         .withHeaders(headers + (authHeaderName -> secretKey))
         .withBody(data)
         .run)

client/shared/src/main/scala/org/scalaexercises/evaluator/http/HttpRequestBuilder.scala

@@ -7,33 +7,30 @@ package org.scalaexercises.evaluator.http
 
 import org.scalaexercises.evaluator.http.HttpClient._
 
-import scala.concurrent.duration.Duration
-import scalaj.http.{Http, HttpOptions}
+import scala.concurrent.Future
+
+import fr.hmil.roshttp.body.Implicits._
+import fr.hmil.roshttp.{HttpRequest, Method, HttpResponse}
+import fr.hmil.roshttp.body.JSONBody
 
 case class HttpRequestBuilder(
   url: String,
   httpVerb: String,
-  connTimeout: Duration,
-  readTimeout: Duration,
-  followRedirects: Boolean = true,
   headers: Headers = Map.empty[String, String],
-  body: Option[String] = None
+  body: String = ""
 ) {
 
   def withHeaders(headers: Headers) = copy(headers = headers)
 
-  def withBody(body: String) = copy(body = Option(body))
+  def withBody(body: String) = copy(body = body)
+
+  def run: Future[HttpResponse] = {
 
-  def run = {
-    val request = Http(url).method(httpVerb).headers(headers)
+    val request = HttpRequest(url)
+      .withMethod(Method(httpVerb))
+      .withHeaders(headers.toList: _*)
+      .withHeader("content.type", "application/json")
 
-    body
-      .fold(request)(
-        request
-          .option(HttpOptions.connTimeout(connTimeout.toMillis.toInt))
-          .option(HttpOptions.readTimeout(readTimeout.toMillis.toInt))
-          .postData(_)
-          .header("content-type", "application/json"))
-      .asString
+    request.post(JSONBody(body))
   }
 }