Fixed: MissingCoreLibraryException when running script in FIJI #10

Author: jpsacha

src/main/scala/dotty/tools/repl/SciJavaScriptEngine.scala

@@ -0,0 +1,104 @@
+package dotty.tools.repl
+
+// This file is based on dotty.tools.repl.ScriptEngine in Scala Compiler
+// It is using some package private classes from `dotty.tools.repl`
+// Only necessary changes are made, no corrects existing compiler warnings, etc. 
+
+import dotty.tools.dotc
+import dotty.tools.dotc.core.StdNames.str
+
+import java.io.{Reader, StringWriter}
+import javax.script.{AbstractScriptEngine, Bindings, ScriptContext, ScriptEngineFactory, ScriptException, SimpleBindings, ScriptEngine as JScriptEngine}
+import scala.language.unsafeNulls
+
+/**
+ * A JSR 223 (Scripting API) compatible wrapper around the REPL for improved
+ *  interoperability with software that supports it.
+ *
+ *  It works by instantiating a new script engine through the script engine manager.
+ *  The script engine provides a eval method to evaluate scripts in string form.
+ *  Example use:
+ *
+ *  val m = new javax.script.ScriptEngineManager()
+ *  val e = m.getEngineByName("scala")
+ *  println(e.eval("42"))
+ */
+class SciJavaScriptEngine(classPath: String) extends AbstractScriptEngine {
+  new javax.script.ScriptEngineManager()
+  private val driver = new ReplDriver(
+    Array(
+      "-classpath",
+      classPath,
+      "-usejavacp",
+      "-color:never",
+      "-Xrepl-disable-display"
+    ),
+    Console.out,
+    None
+  )
+  private val rendering    = new Rendering(Some(getClass.getClassLoader))
+  private var state: State = driver.initialState
+
+  def getFactory: ScriptEngineFactory = new ScriptEngine.Factory
+
+  def createBindings: Bindings = new SimpleBindings
+
+  /* Evaluate with the given context. */
+  @throws[ScriptException]
+  def eval(script: String, context: ScriptContext): Object = {
+    val vid = state.valIndex
+    state = driver.run(script)(using state)
+    val oid = state.objectIndex
+    Class.forName(s"${Rendering.REPL_WRAPPER_NAME_PREFIX}$oid", true, rendering.classLoader()(using state.context))
+      .getDeclaredMethods.find(_.getName == s"${str.REPL_RES_PREFIX}$vid")
+      .map(_.invoke(null))
+      .getOrElse(null)
+  }
+
+  @throws[ScriptException]
+  def eval(reader: Reader, context: ScriptContext): Object = eval(stringFromReader(reader), context)
+
+  private val buffer = new Array[Char](8192)
+
+  def stringFromReader(in: Reader) = {
+    val out = new StringWriter
+    var n   = in.read(buffer)
+    while (n > -1) {
+      out.write(buffer, 0, n)
+      n = in.read(buffer)
+    }
+    in.close
+    out.toString
+  }
+}
+
+object SciJavaScriptEngine {
+  import java.util.Arrays
+  import scala.util.Properties
+  class Factory(classPath: String) extends ScriptEngineFactory {
+    def getEngineName      = "Scala REPL for SciJava"
+    def getEngineVersion   = "3.0"
+    def getExtensions      = Arrays.asList("scala")
+    def getLanguageName    = "Scala"
+    def getLanguageVersion = Properties.versionString
+    def getMimeTypes       = Arrays.asList("application/x-scala")
+    def getNames           = Arrays.asList("scala")
+
+    def getMethodCallSyntax(obj: String, m: String, args: String*) = s"$obj.$m(${args.mkString(", ")})"
+
+    def getOutputStatement(toDisplay: String) = s"""print("$toDisplay")"""
+
+    def getParameter(key: String): Object = key match {
+      case JScriptEngine.ENGINE           => getEngineName
+      case JScriptEngine.ENGINE_VERSION   => getEngineVersion
+      case JScriptEngine.LANGUAGE         => getLanguageName
+      case JScriptEngine.LANGUAGE_VERSION => getLanguageVersion
+      case JScriptEngine.NAME             => getNames.get(0)
+      case _                              => null
+    }
+
+    def getProgram(statements: String*) = statements.mkString("; ")
+
+    def getScriptEngine: JScriptEngine = new SciJavaScriptEngine(classPath)
+  }
+}

src/main/scala/org/scijava/plugins/scripting/scala/ScalaAdaptedScriptEngineFactory.scala

@@ -31,6 +31,7 @@ package org.scijava.plugins.scripting.scala
 
 import org.scijava.plugins.scripting.scala.ScalaAdaptedScriptEngine
 
+import java.net.URLClassLoader
 import java.util
 import javax.script.{ScriptEngine, ScriptEngineFactory}
 
@@ -42,7 +43,7 @@ import javax.script.{ScriptEngine, ScriptEngineFactory}
  */
 class ScalaAdaptedScriptEngineFactory extends ScriptEngineFactory:
 
-  private val factory = new dotty.tools.repl.ScriptEngine.Factory
+  private val factory = new dotty.tools.repl.SciJavaScriptEngine.Factory(classPath)
 
   /**
    * Returns an instance of the `ScalaAdaptedScriptEngine`.
@@ -64,3 +65,12 @@ class ScalaAdaptedScriptEngineFactory extends ScriptEngineFactory:
   override def getMethodCallSyntax(obj: String, m: String, args: String*): String =
     factory.getMethodCallSyntax(obj, m, args*)
   override def getProgram(statements: String*): String = factory.getProgram(statements*)
+
+  /**
+   * Retrieves the current classpath as a string.
+   */
+  def classPath: String = ClassLoader.getSystemClassLoader match
+    case cl: URLClassLoader =>
+      cl.getURLs.map(_.getPath).mkString(System.getProperty("path.separator"))
+    case _ =>
+      System.getProperty("java.class.path")