Fix #3589: Use java.nio.file.Path instead of VirtualBinaryFile

Author: gzm0

js-envs-test-kit/src/main/scala/org/scalajs/jsenv/test/RunTests.scala

@@ -12,10 +12,11 @@
 
 package org.scalajs.jsenv.test
 
+import com.google.common.jimfs.Jimfs
+
 import org.junit.Assume._
 import org.junit.{Test, Before, AssumptionViolatedException}
 
-import org.scalajs.io.VirtualBinaryFile
 import org.scalajs.jsenv._
 import org.scalajs.jsenv.test.kit.{TestKit, Run}
 
@@ -133,13 +134,7 @@ private[test] class RunTests(config: JSEnvSuiteConfig, withCom: Boolean) {
 
   @Test
   def noThrowOnBadFileTest: Unit = {
-    def fail() = throw new java.io.IOException("exception for test")
-
-    val badFile = new VirtualBinaryFile {
-      def path: String = fail()
-      def exists: Boolean = fail()
-      def inputStream: java.io.InputStream = fail()
-    }
+    val badFile = Jimfs.newFileSystem().getPath("nonexistent")
 
     // `start` may not throw but must fail asynchronously
     withRun(Input.ScriptsToLoad(badFile :: Nil)) {

js-envs-test-kit/src/main/scala/org/scalajs/jsenv/test/kit/TestKit.scala

@@ -16,9 +16,12 @@ import scala.concurrent.ExecutionContext
 import scala.concurrent.duration.FiniteDuration
 
 import java.io.InputStream
+import java.nio.charset.StandardCharsets
+import java.nio.file._
 import java.util.concurrent.Executors
 
-import org.scalajs.io.MemVirtualBinaryFile
+import com.google.common.jimfs.Jimfs
+
 import org.scalajs.jsenv._
 
 /** TestKit is a utility class to simplify testing of [[JSEnv]]s.
@@ -152,7 +155,9 @@ private object TestKit {
     ExecutionContext.fromExecutor(Executors.newSingleThreadExecutor())
 
   private def codeToInput(code: String): Input = {
-    val vf = MemVirtualBinaryFile.fromStringUTF8("testScript.js", code)
-    Input.ScriptsToLoad(List(vf))
+    val p = Files.write(
+        Jimfs.newFileSystem().getPath("testScript.js"),
+        code.getBytes(StandardCharsets.UTF_8))
+    Input.ScriptsToLoad(List(p))
   }
 }

js-envs/src/main/scala/org/scalajs/jsenv/Input.scala

@@ -12,7 +12,7 @@
 
 package org.scalajs.jsenv
 
-import org.scalajs.io._
+import java.nio.file.Path
 
 /** Input to a [[JSEnv]].
  *
@@ -27,7 +27,7 @@ abstract class Input private ()
 
 object Input {
   /** All files are to be loaded as scripts into the global scope in the order given. */
-  final case class ScriptsToLoad(scripts: List[VirtualBinaryFile]) extends Input
+  final case class ScriptsToLoad(scripts: List[Path]) extends Input
 
   /** All files are to be loaded as ES modules, in the given order.
    *
@@ -36,11 +36,11 @@ object Input {
    *  `ESModulesToLoad` input if the `modules` argument has more than one
    *  element.
    */
-  final case class ESModulesToLoad(modules: List[VirtualBinaryFile])
+  final case class ESModulesToLoad(modules: List[Path])
       extends Input
 
   /** All files are to be loaded as CommonJS modules, in the given order. */
-  final case class CommonJSModulesToLoad(modules: List[VirtualBinaryFile])
+  final case class CommonJSModulesToLoad(modules: List[Path])
       extends Input
 }
 

nodejs-env/src/main/scala/org/scalajs/jsenv/nodejs/ComSupport.scala

@@ -12,12 +12,6 @@
 
 package org.scalajs.jsenv.nodejs
 
-import java.io._
-import java.net._
-
-import org.scalajs.io.{VirtualBinaryFile, MemVirtualBinaryFile}
-import org.scalajs.jsenv._
-
 import scala.collection.immutable
 import scala.concurrent._
 import scala.util.{Failure, Success}
@@ -26,6 +20,15 @@ import scala.util.control.NonFatal
 // TODO Replace this by a better execution context on the RunConfig.
 import scala.concurrent.ExecutionContext.Implicits.global
 
+import java.io._
+import java.net._
+import java.nio.charset.StandardCharsets
+import java.nio.file._
+
+import com.google.common.jimfs.Jimfs
+
+import org.scalajs.jsenv._
+
 private final class ComRun(run: JSRun, handleMessage: String => Unit,
     serverSocket: ServerSocket) extends JSComRun {
   import ComRun._
@@ -200,11 +203,10 @@ object ComRun {
    *  @param config Configuration for the run.
    *  @param onMessage callback upon message reception.
    *  @param startRun [[JSRun]] launcher. Gets passed a
-   *      [[org.scalajs.io.VirtualBinaryFile VirtualBinaryFile]] that
-   *      initializes `scalaJSCom` on `global`. Requires Node.js libraries.
+   *      [[java.nio.file.Path Path]] that initializes `scalaJSCom` on
+   *      `global`. Requires Node.js libraries.
    */
-  def start(config: RunConfig, onMessage: String => Unit)(
-      startRun: VirtualBinaryFile => JSRun): JSComRun = {
+  def start(config: RunConfig, onMessage: String => Unit)(startRun: Path => JSRun): JSComRun = {
     try {
       val serverSocket =
         new ServerSocket(0, 0, InetAddress.getByName(null)) // Loopback address
@@ -240,8 +242,9 @@ object ComRun {
     s.writeChars(msg)
   }
 
-  private def setupFile(port: Int): VirtualBinaryFile = {
-    MemVirtualBinaryFile.fromStringUTF8("comSetup.js",
+  private def setupFile(port: Int): Path = {
+    Files.write(
+        Jimfs.newFileSystem().getPath("comSetup.js"),
         s"""
            |(function() {
            |  // The socket for communication
@@ -303,6 +306,6 @@ object ComRun {
            |    }
            |  }
            |}).call(this);
-        """.stripMargin)
+        """.stripMargin.getBytes(StandardCharsets.UTF_8))
   }
 }

nodejs-env/src/main/scala/org/scalajs/jsenv/nodejs/NodeJSEnv.scala

@@ -12,18 +12,19 @@
 
 package org.scalajs.jsenv.nodejs
 
-import java.nio.charset.StandardCharsets
 
 import scala.annotation.tailrec
-import scala.collection.JavaConverters._
+
+import java.io._
+import java.nio.charset.StandardCharsets
+import java.nio.file._
 
 import org.scalajs.jsenv._
 import org.scalajs.jsenv.JSUtils.escapeJS
 
-import org.scalajs.io._
 import org.scalajs.logging._
 
-import java.io._
+import com.google.common.jimfs.Jimfs
 
 final class NodeJSEnv(config: NodeJSEnv.Config) extends JSEnv {
   import NodeJSEnv._
@@ -57,8 +58,7 @@ final class NodeJSEnv(config: NodeJSEnv.Config) extends JSEnv {
     }
   }
 
-  private def internalStart(initFiles: List[VirtualBinaryFile], input: Input,
-      runConfig: RunConfig): JSRun = {
+  private def internalStart(initFiles: List[Path], input: Input, runConfig: RunConfig): JSRun = {
     val command = config.executable :: config.args
     val externalConfig = ExternalJSRun.Config()
       .withEnv(env)
@@ -67,7 +67,7 @@ final class NodeJSEnv(config: NodeJSEnv.Config) extends JSEnv {
         NodeJSEnv.write(initFiles, input))
   }
 
-  private def initFiles: List[VirtualBinaryFile] = config.sourceMap match {
+  private def initFiles: List[Path] = config.sourceMap match {
     case SourceMap.Disable           => Nil
     case SourceMap.EnableIfAvailable => installSourceMapIfAvailable :: Nil
     case SourceMap.Enable            => installSourceMap :: Nil
@@ -83,43 +83,45 @@ final class NodeJSEnv(config: NodeJSEnv.Config) extends JSEnv {
 }
 
 object NodeJSEnv {
+  private lazy val fs = Jimfs.newFileSystem()
+
   private lazy val validator = ExternalJSRun.supports(RunConfig.Validator())
 
   private lazy val installSourceMapIfAvailable = {
-    MemVirtualBinaryFile.fromStringUTF8("sourceMapSupport.js",
+    Files.write(
+        fs.getPath("optionalSourceMapSupport.js"),
         """
           |try {
           |  require('source-map-support').install();
           |} catch (e) {
           |};
-        """.stripMargin
-    )
+        """.stripMargin.getBytes(StandardCharsets.UTF_8))
   }
 
   private lazy val installSourceMap = {
-    MemVirtualBinaryFile.fromStringUTF8("sourceMapSupport.js",
-        "require('source-map-support').install();")
+    Files.write(
+        fs.getPath("sourceMapSupport.js"),
+        "require('source-map-support').install();".getBytes(StandardCharsets.UTF_8))
   }
 
-  private def write(initFiles: List[VirtualBinaryFile], input: Input)(
-      out: OutputStream): Unit = {
+  private def write(initFiles: List[Path], input: Input)(out: OutputStream): Unit = {
     val p = new PrintStream(out, false, "UTF8")
     try {
-      def writeRunScript(file: VirtualBinaryFile): Unit = {
-        file match {
-          case file: FileVirtualBinaryFile =>
-            val pathJS = "\"" + escapeJS(file.file.getAbsolutePath) + "\""
-            p.println(s"""
-              require('vm').runInThisContext(
-                require('fs').readFileSync($pathJS, { encoding: "utf-8" }),
-                { filename: $pathJS, displayErrors: true }
-              );
-            """)
-
-          case _ =>
-            val code = readInputStreamToString(file.inputStream)
+      def writeRunScript(path: Path): Unit = {
+        try {
+          val f = path.toFile
+          val pathJS = "\"" + escapeJS(f.getAbsolutePath) + "\""
+          p.println(s"""
+            require('vm').runInThisContext(
+              require('fs').readFileSync($pathJS, { encoding: "utf-8" }),
+              { filename: $pathJS, displayErrors: true }
+            );
+          """)
+        } catch {
+          case _: UnsupportedOperationException =>
+            val code = new String(Files.readAllBytes(path), StandardCharsets.UTF_8)
             val codeJS = "\"" + escapeJS(code) + "\""
-            val pathJS = "\"" + escapeJS(file.path) + "\""
+            val pathJS = "\"" + escapeJS(path.toString) + "\""
             p.println(s"""
               require('vm').runInThisContext(
                 $codeJS,
@@ -129,17 +131,6 @@ object NodeJSEnv {
         }
       }
 
-      def writeRequire(file: VirtualBinaryFile): Unit = {
-        file match {
-          case file: FileVirtualBinaryFile =>
-            p.println(s"""require("${escapeJS(file.file.getAbsolutePath)}")""")
-
-          case _ =>
-            val f = tmpFile(file.path, file.inputStream)
-            p.println(s"""require("${escapeJS(f.getAbsolutePath)}")""")
-        }
-      }
-
       for (initFile <- initFiles)
         writeRunScript(initFile)
 
@@ -150,16 +141,11 @@ object NodeJSEnv {
 
         case Input.CommonJSModulesToLoad(modules) =>
           for (module <- modules)
-            writeRequire(module)
+            p.println(s"""require("${escapeJS(toFile(module).getAbsolutePath)}")""")
 
         case Input.ESModulesToLoad(modules) =>
           if (modules.nonEmpty) {
-            val uris = modules.map {
-              case module: FileVirtualBinaryFile =>
-                module.file.toURI
-              case module =>
-                tmpFile(module.path, module.inputStream).toURI
-            }
+            val uris = modules.map(m => toFile(m).toURI)
 
             val imports = uris.map { uri =>
               s"""import("${escapeJS(uri.toASCIIString)}")"""
@@ -176,7 +162,8 @@ object NodeJSEnv {
                 |});
               """.stripMargin
             }
-            val f = tmpFile("importer.js", importerFileContent)
+            val f = createTmpFile("importer.js")
+            Files.write(f.toPath, importerFileContent.getBytes(StandardCharsets.UTF_8))
             p.println(s"""require("${escapeJS(f.getAbsolutePath)}");""")
           }
       }
@@ -185,48 +172,14 @@ object NodeJSEnv {
     }
   }
 
-  private def readInputStreamToString(inputStream: InputStream): String = {
-    val baos = new java.io.ByteArrayOutputStream
-    val in = inputStream
+  private def toFile(path: Path): File = {
     try {
-      val buf = new Array[Byte](4096)
-
-      @tailrec
-      def loop(): Unit = {
-        val read = in.read(buf)
-        if (read != -1) {
-          baos.write(buf, 0, read)
-          loop()
-        }
-      }
-
-      loop()
-    } finally {
-      in.close()
-    }
-    new String(baos.toByteArray(), StandardCharsets.UTF_8)
-  }
-
-  private def tmpFile(path: String, content: String): File = {
-    import java.nio.file.{Files, StandardOpenOption}
-
-    val f = createTmpFile(path)
-    val contentList = new java.util.ArrayList[String]()
-    contentList.add(content)
-    Files.write(f.toPath(), contentList, StandardCharsets.UTF_8,
-        StandardOpenOption.TRUNCATE_EXISTING)
-    f
-  }
-
-  private def tmpFile(path: String, content: InputStream): File = {
-    import java.nio.file.{Files, StandardCopyOption}
-
-    try {
-      val f = createTmpFile(path)
-      Files.copy(content, f.toPath(), StandardCopyOption.REPLACE_EXISTING)
-      f
-    } finally {
-      content.close()
+      path.toFile
+    } catch {
+      case _: UnsupportedOperationException =>
+        val f = createTmpFile(path.toString)
+        Files.copy(path, f.toPath(), StandardCopyOption.REPLACE_EXISTING)
+        f
     }
   }