Pass scalac flags to the endpoint

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

@@ -16,4 +16,4 @@ class EvaluatorAPI[F[_]](url: String, authKey: String)(
                 dependencies: List[Dependency] = Nil,
                 code: String): Free[F, EvaluationResponse[EvalResponse]] =
     O.evaluates(url, authKey, resolvers, dependencies, code)
-}
+}

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

@@ -5,11 +5,11 @@
 
 package org.scalaexercises.evaluator.api
 
-import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
-import org.scalaexercises.evaluator.{Decoders, Dependency, EvalRequest, EvalResponse}
-import org.scalaexercises.evaluator.http.HttpClient
 import io.circe.generic.auto._
 import io.circe.syntax._
+import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
+import org.scalaexercises.evaluator.http.HttpClient
+import org.scalaexercises.evaluator.{Decoders, Dependency, EvalRequest, EvalResponse}
 
 import scala.concurrent.Future
 

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

@@ -6,8 +6,8 @@
 package org.scalaexercises.evaluator.free.algebra
 
 import cats.free.{Free, Inject}
-import org.scalaexercises.evaluator.{Dependency, EvalResponse}
 import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
+import org.scalaexercises.evaluator.{Dependency, EvalResponse}
 
 sealed trait EvaluatorOp[A]
 final case class Evaluates(url: String,

server/src/main/resources/application.conf

@@ -12,4 +12,4 @@ eval.auth {
 
 # Loader IO Configuration
 loaderio.verificationToken=loaderio-changeme
-loaderio.verificationToken=${?LOADERIO_VERIFICATION_TOKEN}
+loaderio.verificationToken=${?LOADERIO_VERIFICATION_TOKEN}

server/src/main/scala/org/scalaexercises/evaluator/evaluation.scala

@@ -5,34 +5,29 @@
 
 package org.scalaexercises.evaluator
 
-import scala.language.reflectiveCalls
-
-import java.io.{File, InputStream}
+import java.io.File
+import java.math.BigInteger
 import java.net.URLClassLoader
-import java.nio.file.Path
-import java.util.jar.JarFile
-import java.util.concurrent.TimeoutException
 import java.security.MessageDigest
-import java.math.BigInteger
+import java.util.concurrent.TimeoutException
+import java.util.jar.JarFile
 
-import scala.tools.nsc.{Global, Settings}
-import scala.tools.nsc.reporters._
-import scala.tools.nsc.io.{VirtualDirectory, AbstractFile}
-import scala.reflect.internal.util.{Position, NoPosition, BatchSourceFile, AbstractFileClassLoader}
+import coursier._
+import monix.execution.Scheduler
+import org.scalaexercises.evaluator.Eval.CompilerException
 
-import scalaz._; import Scalaz._
+import scala.concurrent.duration._
+import scala.language.reflectiveCalls
+import scala.reflect.internal.util.{AbstractFileClassLoader, BatchSourceFile, Position}
+import scala.tools.nsc.io.{AbstractFile, VirtualDirectory}
+import scala.tools.nsc.reporters._
+import scala.tools.nsc.{Global, Settings}
 import scala.util.Try
 import scala.util.control.NonFatal
-import scala.concurrent._
-import scala.concurrent.duration._
+import scalaz.Scalaz._
+import scalaz._
 import scalaz.concurrent.Task
 
-import monix.execution.Scheduler
-
-import coursier._
-
-import org.scalaexercises.evaluator._
-
 class Evaluator(timeout: FiniteDuration = 20.seconds)(
   implicit S: Scheduler
 ) {
@@ -78,9 +73,14 @@ class Evaluator(timeout: FiniteDuration = 20.seconds)(
       @volatile var errors: Map[String, List[CompilationInfo]] = Map.empty
 
       override lazy val compilerSettings: Settings = new EvalSettings(None) {
-        if (!jars.isEmpty) {
+        if (jars.nonEmpty) {
           val newJars = jars.mkString(File.pathSeparator)
           classpath.value = newJars + File.pathSeparator + classpath.value
+
+          (jars map (_.toString)).find(_.contains("paradise")) match {
+            case Some(compilerJar) => plugin.appendToValue(compilerJar)
+            case None              =>
+          }
         }
       }
 
@@ -115,7 +115,7 @@ class Evaluator(timeout: FiniteDuration = 20.seconds)(
       case scala.util.Success(r) ⇒ EvalSuccess[T](errors, r, "")
       case scala.util.Failure(t) ⇒
         t match {
-          case e: Eval.CompilerException ⇒ CompilationError(errors)
+          case e: CompilerException ⇒ CompilationError(errors)
           case NonFatal(e) ⇒
             EvalRuntimeError(errors, Option(RuntimeError(e, None)))
           case e ⇒ GeneralError(e)
@@ -253,7 +253,7 @@ private class StringCompiler(
         case _ =>
           List(List(reporter.toString))
       }
-      throw new Eval.CompilerException(msgs)
+      throw new CompilerException(msgs)
     }
   }
 

server/src/main/scala/org/scalaexercises/evaluator/services.scala

@@ -5,23 +5,20 @@
 
 package org.scalaexercises.evaluator
 
+import monix.execution.Scheduler
 import org.http4s._
 import org.http4s.dsl._
-import org.http4s.server._
 import org.http4s.server.blaze._
 import org.log4s.getLogger
-import monix.execution.Scheduler
 
-import scala.language.postfixOps
-import scalaz.concurrent.Task
-import scalaz._
 import scala.concurrent.duration._
+import scala.language.postfixOps
 
 object services {
 
+  import EvalResponse.messages._
   import codecs._
   import io.circe.generic.auto._
-  import EvalResponse.messages._
 
   private val logger = getLogger
 

server/src/test/scala/org/scalaexercises/evaluator/EvalEndpointSpec.scala

@@ -5,27 +5,25 @@
 
 package org.scalaexercises.evaluator
 
-import org.scalatest._
-import org.http4s._
-import org.http4s.headers._
-import org.http4s.dsl._
-import org.http4s.server._
+import java.nio.charset.StandardCharsets
 
-import io.circe.syntax._
 import io.circe.generic.auto._
-import scalaz.stream.Process.emit
-import java.nio.charset.StandardCharsets
+import io.circe.syntax._
+import org.http4s.dsl._
+import org.http4s.headers._
+import org.http4s.{Status => HttpStatus, _}
+import org.scalatest._
+import pdi.jwt.{Jwt, JwtAlgorithm}
 import scodec.bits.ByteVector
-import pdi.jwt.{Jwt, JwtAlgorithm, JwtHeader, JwtClaim, JwtOptions}
 
-import org.http4s.{Status => HttpStatus}
+import scalaz.stream.Process.emit
 
 class EvalEndpointSpec extends FunSpec with Matchers {
 
-  import services._
-  import codecs._
-  import auth._
   import EvalResponse.messages._
+  import auth._
+  import codecs._
+  import services._
 
   val sonatypeReleases = "https://oss.sonatype.org/content/repositories/releases/" :: Nil
 

server/src/test/scala/org/scalaexercises/evaluator/EvaluatorSpec.scala

@@ -5,16 +5,19 @@
 
 package org.scalaexercises.evaluator
 
-import scala.concurrent.duration._
-import scala.language.postfixOps
 import monix.execution.Scheduler
 import org.scalatest._
 import org.scalatest.exceptions.TestFailedException
 
+import scala.concurrent.duration._
+import scala.language.postfixOps
+
 class EvaluatorSpec extends FunSpec with Matchers {
   implicit val scheduler: Scheduler = Scheduler.io("exercises-spec")
   val evaluator                     = new Evaluator(20 seconds)
 
+  val remotes = "https://oss.sonatype.org/content/repositories/releases/" :: Nil
+
   describe("evaluation") {
     it("can evaluate simple expressions") {
       val result: EvalResult[Int] = evaluator.eval("{ 41 + 1 }").run
@@ -33,58 +36,32 @@ class EvaluatorSpec extends FunSpec with Matchers {
       }
     }
 
-    ignore("can load dependencies for an evaluation") {
-      val code = """
-import cats._
+    describe("can load dependencies for an evaluation") {
+      val code = "{import cats._; Eval.now(42).value}"
 
-Eval.now(42).value
-      """
-      val remotes =
-        List("https://oss.sonatype.org/content/repositories/releases/")
-      val dependencies = List(
-        Dependency("org.typelevel", "cats_2.11", "0.6.0")
-      )
+      val dependencies = Dependency("org.typelevel", "cats_2.11", "0.6.0") :: Nil
 
       val result: EvalResult[Int] = evaluator
-        .eval(
-          code,
-          remotes = remotes,
-          dependencies = dependencies
-        )
+        .eval(code, remotes = remotes, dependencies = dependencies)
         .run
 
       result should matchPattern {
         case EvalSuccess(_, 42, _) =>
       }
     }
 
-    ignore("can load different versions of a dependency across evaluations") {
-      val code = """
-import cats._
-Eval.now(42).value
-      """
-      val remotes =
-        List("https://oss.sonatype.org/content/repositories/releases/")
-      val dependencies1 = List(
-        Dependency("org.typelevel", "cats_2.11", "0.4.1")
-      )
-      val dependencies2 = List(
-        Dependency("org.typelevel", "cats_2.11", "0.6.0")
-      )
+    describe("can load different versions of a dependency across evaluations") {
+      val code = "{import cats._; Eval.now(42).value}"
+
+      val dependencies1 = Dependency("org.typelevel", "cats_2.11", "0.4.1") :: Nil
+
+      val dependencies2 = Dependency("org.typelevel", "cats_2.11", "0.6.0") :: Nil
 
       val result1: EvalResult[Int] = evaluator
-        .eval(
-          code,
-          remotes = remotes,
-          dependencies = dependencies1
-        )
+        .eval(code, remotes = remotes, dependencies = dependencies1)
         .run
       val result2: EvalResult[Int] = evaluator
-        .eval(
-          code,
-          remotes = remotes,
-          dependencies = dependencies2
-        )
+        .eval(code, remotes = remotes, dependencies = dependencies2)
         .run
 
       result1 should matchPattern {
@@ -95,47 +72,33 @@ Eval.now(42).value
       }
     }
 
-    ignore("can run code from the exercises content") {
-      val code = """
-import stdlib._
-Asserts.scalaTestAsserts(true)
-"""
-      val remotes =
-        List("https://oss.sonatype.org/content/repositories/releases/")
-      val dependencies = List(
-        Dependency("org.scala-exercises", "exercises-stdlib_2.11", "0.2.0")
-      )
+    describe("can run code from the exercises content") {
+      val code = "{import stdlib._; Asserts.scalaTestAsserts(true)}"
+
+      val dependencies = Dependency(
+          "org.scala-exercises",
+          "exercises-stdlib_2.11",
+          "0.2.0") :: Nil
 
       val result: EvalResult[Unit] = evaluator
-        .eval(
-          code,
-          remotes = remotes,
-          dependencies = dependencies
-        )
+        .eval(code, remotes = remotes, dependencies = dependencies)
         .run
 
       result should matchPattern {
         case EvalSuccess(_, (), _) =>
       }
     }
 
-    ignore("captures exceptions when running the exercises content") {
-      val code = """
-import stdlib._
-Asserts.scalaTestAsserts(false)
-"""
-      val remotes =
-        List("https://oss.sonatype.org/content/repositories/releases/")
-      val dependencies = List(
-        Dependency("org.scala-exercises", "exercises-stdlib_2.11", "0.2.0")
-      )
+    describe("captures exceptions when running the exercises content") {
+      val code = "{import stdlib._; Asserts.scalaTestAsserts(false)}"
+
+      val dependencies = Dependency(
+          "org.scala-exercises",
+          "exercises-stdlib_2.11",
+          "0.2.0") :: Nil
 
       val result: EvalResult[Unit] = evaluator
-        .eval(
-          code,
-          remotes = remotes,
-          dependencies = dependencies
-        )
+        .eval(code, remotes = remotes, dependencies = dependencies)
         .run
 
       result should matchPattern {
@@ -144,5 +107,20 @@ Asserts.scalaTestAsserts(false)
             Some(RuntimeError(err: TestFailedException, _))) =>
       }
     }
+
+    describe("can run code from the exercises content") {
+      val code = "{import cats._; Eval.now(42).value}"
+
+      val dependencies = Dependency("org.typelevel", "cats_2.11", "0.6.0") :: Nil
+
+      val result: EvalResult[Unit] = evaluator
+        .eval(code, remotes = remotes, dependencies = dependencies)
+        .run
+
+      result should matchPattern {
+        case EvalSuccess(_, 42, _) =>
+      }
+    }
+
   }
 }