Merge pull request #85 from scala-exercises/jp-resource-proposal

Replaces scala.util.Try by cats.effect.Resource

Author: kiroco12

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

@@ -12,7 +12,7 @@ import java.math.BigInteger
 import java.security.MessageDigest
 import java.util.jar.JarFile
 
-import cats.effect.{Concurrent, ConcurrentEffect, Timer}
+import cats.effect._
 import cats.implicits._
 import coursier._
 import coursier.cache.{ArtifactError, FileCache}
@@ -22,12 +22,12 @@ import org.scalaexercises.evaluator.{Dependency => EvaluatorDependency}
 
 import scala.concurrent.duration._
 import scala.language.reflectiveCalls
-import scala.reflect.internal.util.{AbstractFileClassLoader, BatchSourceFile, Position}
 import scala.reflect.internal.util.ScalaClassLoader.URLClassLoader
+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.{Failure, Success, Try}
+import scala.util.Try
 import scala.util.control.NonFatal
 
 class Evaluator[F[_]: Sync](timeout: FiniteDuration = 20.seconds)(
@@ -462,35 +462,35 @@ class ${className} extends (() => Any) with java.io.Serializable {
     val classPath        = getClassPath(this.getClass.getClassLoader)
     val currentClassPath = classPath.head
 
+    def checkCurrentClassPath: List[String] = currentClassPath match {
+      case List(jarFile) if jarFile.endsWith(".jar") =>
+        val relativeRoot = new File(jarFile).getParentFile
+        val jarResource: Resource[IO, JarFile] =
+          Resource.make(IO(new JarFile(jarFile)))(jar => IO(jar.close()))
+
+        val nestedClassPath: IO[String] =
+          jarResource
+            .use(jar => IO(jar.getManifest.getMainAttributes.getValue("Class-Path")))
+            .handleError { throwable: Throwable =>
+              throw new CompilerException(List(List(throwable.getMessage)))
+            }
+
+        nestedClassPath.map {
+          case ncp if ncp eq null => Nil
+          case ncp =>
+            ncp
+              .split(" ")
+              .map { f =>
+                new File(relativeRoot, f).getAbsolutePath
+              }
+              .toList
+
+        }.unsafeRunSync
+      case _ => Nil
+    }
+
     // if there's just one thing in the classpath, and it's a jar, assume an executable jar.
-    currentClassPath ::: (if (currentClassPath.size == 1 && currentClassPath.head
-                              .endsWith(".jar")) {
-                            val jarFile = currentClassPath.head
-                            val relativeRoot =
-                              new File(jarFile).getParentFile
-                            val nestedClassPath = Try {
-                              val jar = new JarFile(jarFile)
-                              val CP  = jar.getManifest.getMainAttributes.getValue("Class-Path")
-                              jar.close()
-                              CP
-                            } match {
-                              case Success(classPath) => classPath
-                              case Failure(throwable) =>
-                                throw new CompilerException(List(List(throwable.getMessage)))
-                            }
-                            if (nestedClassPath eq null) {
-                              Nil
-                            } else {
-                              nestedClassPath
-                                .split(" ")
-                                .map { f =>
-                                  new File(relativeRoot, f).getAbsolutePath
-                                }
-                                .toList
-                            }
-                          } else {
-                            Nil
-                          }) ::: classPath.tail.flatten
+    currentClassPath ::: checkCurrentClassPath ::: classPath.tail.flatten
   }
 
   lazy val compilerOutputDir = target match {