scriptrunner: use default imports, which fixes e.g. Operator usage

re joernio/joern#5558

Author: mpollmeier

core/src/main/scala-3.7.1/replpp/InteractiveShell.scala

@@ -2,8 +2,6 @@ package replpp
 
 import dotty.tools.repl.State
 
-import scala.util.control.NoStackTrace
-
 object InteractiveShell {
 
   def run(config: Config): Unit = {

core/src/main/scala/replpp/scripting/ScriptRunner.scala

@@ -1,6 +1,6 @@
 package replpp.scripting
 
-import replpp.{Config, verboseEnabled}
+import replpp.{Colors, Config, DefaultRunBeforeLines, globalRunBeforeLines, verboseEnabled}
 import replpp.util.ClasspathHelper
 
 import scala.util.{Failure, Success, Try}
@@ -18,16 +18,18 @@ object ScriptRunner {
   def exec(config: Config): Try[Unit] = {
     val classpath = ClasspathHelper.create(config, quiet = true)
     val mainClass = "replpp.scripting.NonForkingScriptRunner"
+    val defaultRunBeforeLines = DefaultRunBeforeLines(using Colors.BlackWhite) ++ globalRunBeforeLines
+    val config0 = config.copy(runBefore = defaultRunBeforeLines ++ config.runBefore)
     val args = {
       val builder = Seq.newBuilder[String]
       if (config.remoteJvmDebugEnabled) builder += RemoteJvmDebugConfig
       builder ++= Seq("-classpath", classpath)
       builder += mainClass
-      builder ++= config.asJavaArgs
+      builder ++= config0.asJavaArgs
 
       builder.result()
     }
-    if (replpp.verboseEnabled(config))
+    if (replpp.verboseEnabled(config0))
       println(s"executing `java ${args.mkString(" ")}`")
 
     Process("java", args).run().exitValue() match {

core/src/test/scala/replpp/OperatorsTests.scala

@@ -17,6 +17,8 @@ import System.lineSeparator
   import scala.jdk.CollectionConverters.*
   Seq("this is a test", "another one").asJava #|^ "less"
   ```
+
+  Note: additional tests are in 'ScriptRunnerTests'
 */
 class OperatorsTests extends AnyWordSpec with Matchers {
   given Colors = Colors.BlackWhite

core/src/test/scala/replpp/scripting/ScriptRunnerTests.scala

@@ -10,10 +10,19 @@ class ScriptRunnerTests extends AnyWordSpec with Matchers {
   if (scala.util.Properties.isWin) {
     info("tests were cancelled currently fail on windows - not sure why - I'm testing the `--script` mode manually for now and will replace these tests in the future")
   } else {
-    "execute simple single-statement script" in {
+    "execute a simple script" in {
       execTest { testOutputPath =>
-        TestSetup(s"""java.nio.file.Files.writeString(java.nio.file.Path.of("$testOutputPath"), "iwashere-simple")""")
-      }.get shouldBe "iwashere-simple"
+        TestSetup(
+          s"""
+             |Seq("aa", "bb", "cc") #> "$testOutputPath"
+             |"dd" #>>  "$testOutputPath"
+             |""".stripMargin)
+      }.get shouldBe
+        """aa
+          |bb
+          |cc
+          |dd
+          |""".stripMargin
     }
 
     "main entry point" in {
@@ -330,9 +339,10 @@ object ScriptRunnerTests {
     val scriptSrc =
       s"""val i = 2 + 10
          |println("in main/script: i=" + i)
+         |"foo" #> "out.txt"
          |""".stripMargin
     val scriptFile = os.temp(scriptSrc).toNIO
-    val config = Config(scriptFile = Some(scriptFile), verbose = true)
+    val config = Config(scriptFile = Some(scriptFile))// , verbose = true)
     ScriptRunner.exec(config)
   }
 }

server/src/main/scala/replpp/server/EmbeddedRepl.scala

@@ -25,9 +25,10 @@ class EmbeddedRepl(
   private val replDriver = ReplDriver(compilerArgs, new PrintStream(replOutputStream), classLoader = None)
 
   private var state: State = {
-    if (runBeforeCode.nonEmpty)
+    if (runBeforeCode.nonEmpty) {
+      if (verbose) logger.info(s"executing runBeforeCode: \n${runBeforeCode.mkString("\n")}")
       replDriver.execute(runBeforeCode)
-    else 
+    } else
       replDriver.initialState
   }
 
@@ -42,7 +43,9 @@ class EmbeddedRepl(
   def queryAsync(inputLines: IterableOnce[String]): (UUID, Future[String]) = {
     val uuid = UUID.randomUUID()
     val future = Future {
-      state = replDriver.execute(inputLines)(using state)
+      val lines = inputLines.iterator.toSeq
+      if (verbose) logger.info(s"executing: \n${lines.mkString("\n")}")
+      state = replDriver.execute(lines)(using state)
       readAndResetReplOutputStream()
     } (using singleThreadedJobExecutor)
 
@@ -72,14 +75,17 @@ class EmbeddedRepl(
     logger.info("shutting down")
     if (runAfterCode.nonEmpty) {
       if (verbose) logger.info(s"executing: $runAfterCode")
-      replDriver.execute(runAfterCode)
+      state = replDriver.execute(runAfterCode)(using state)
+      val output = readAndResetReplOutputStream()
+      logger.info(output)
     }
     singleThreadedJobExecutor.shutdown()
   }
 }
 
 class ReplDriver(args: Array[String], out: PrintStream, classLoader: Option[ClassLoader])
   extends ReplDriverBase(args, out, maxHeight = None, classLoader)(using BlackWhite) {
-  def execute(inputLines: IterableOnce[String])(using state: State = initialState): State =
+  def execute(inputLines: IterableOnce[String])(using state: State = initialState): State = {
     interpretInput(inputLines, state, pwd)
+  }
 }

server/src/main/scala/replpp/server/ReplServer.scala

@@ -1,8 +1,8 @@
 package replpp.server
 
-import cask.model.{Request, Response}
+import cask.model.Response
 import org.slf4j.LoggerFactory
-import replpp.precompilePredefFiles
+import replpp.{Colors, DefaultRunBeforeLines, globalRunBeforeLines, precompilePredefFiles}
 import ujson.Obj
 
 import java.io.{PrintWriter, StringWriter}
@@ -23,7 +23,8 @@ object ReplServer {
 
     val baseConfig = precompilePredefFiles(serverConfig.baseConfig)
     val compilerArgs = replpp.compilerArgs(baseConfig)
-    val embeddedRepl = new EmbeddedRepl(compilerArgs, baseConfig.runBefore, baseConfig.runAfter, baseConfig.verbose)
+    val runBeforeCode = DefaultRunBeforeLines(using Colors.BlackWhite) ++ globalRunBeforeLines ++ baseConfig.runBefore
+    val embeddedRepl = new EmbeddedRepl(compilerArgs, runBeforeCode, baseConfig.runAfter, baseConfig.verbose)
     Runtime.getRuntime.addShutdownHook(new Thread(() => {
       logger.info("Shutting down embedded repl...")
       embeddedRepl.shutdown()

server/src/test/scala/replpp/server/ReplServerTests.scala

@@ -4,6 +4,7 @@ import cask.util.Logger.Console.*
 import castor.Context.Simple.global
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpec
+import replpp.{Colors, DefaultRunBeforeLines, globalRunBeforeLines}
 import replpp.util.{ClasspathHelper, SimpleDriver, pathAsString}
 import requests.RequestFailedException
 import ujson.Value.Value
@@ -97,7 +98,7 @@ class ReplServerTests extends AnyWordSpec with Matchers {
           val getResultResponse = getResponse(url, queryUUID)
           getResultResponse.obj.keySet should contain("success")
           getResultResponse("uuid").str shouldBe queryResultWSMessage
-          getResultResponse("stdout").str shouldBe "val res0: Int = 1\n"
+          getResultResponse("stdout").str should include("val res0: Int = 1")
         }
 
         "use predefined code" in Fixture("val foo = 40") { url =>
@@ -120,7 +121,7 @@ class ReplServerTests extends AnyWordSpec with Matchers {
           val getResultResponse = getResponse(url, queryUUID)
           getResultResponse.obj.keySet should contain("success")
           getResultResponse("uuid").str shouldBe queryResultWSMessage
-          getResultResponse("stdout").str shouldBe "val bar: Int = 42\n"
+          getResultResponse("stdout").str should include("val bar: Int = 42")
         }
 
         "use runBefore code" in Fixture(runBeforeCode = Seq("import Int.MaxValue")) { url =>
@@ -143,20 +144,20 @@ class ReplServerTests extends AnyWordSpec with Matchers {
           val getResultResponse = getResponse(url, queryUUID)
           getResultResponse.obj.keySet should contain("success")
           getResultResponse("uuid").str shouldBe queryResultWSMessage
-          getResultResponse("stdout").str shouldBe "val bar: Int = 2147483647\n"
+          getResultResponse("stdout").str should include("val bar: Int = 2147483647")
         }
 
         "use runAfter code" in {
-          val expectedFileContent = "this should be written to the test output file"
           val testOutputFile = os.temp(deleteOnExit = false)
           val testOutputPath = replpp.util.pathAsString(testOutputFile.toNIO)
           Fixture(runAfterCode = Seq(
-            "import java.nio.file.*",
-            s"""Files.writeString(Path.of("$testOutputPath"), "$expectedFileContent")""",
-          )) { _ =>
-            // no need to execute anything, we only want to verify the `runAfter` code
+            s"""definedInTest #> "$testOutputPath"""",
+          )) { url =>
+            val response = postQuerySync(url, "val definedInTest = 123456")
+            response.obj.keySet should contain("success")
+            response("stdout").str should include("val definedInTest: Int = 123456")
           }
-          os.read(testOutputFile) shouldBe expectedFileContent
+          os.read(testOutputFile).trim shouldBe "123456"
         }
 
         "disallow fetching the result of a completed query with an invalid auth header" in Fixture() { url =>
@@ -205,7 +206,7 @@ class ReplServerTests extends AnyWordSpec with Matchers {
             getResultResponse.obj.keySet should contain("stdout")
             getResultResponse.obj.keySet should not contain "err"
             getResultResponse("uuid").str shouldBe queryResultWSMessage
-            getResultResponse("stdout").str shouldBe "val res0: Int = 1\n"
+            getResultResponse("stdout").str should include("val res0: Int = 1")
         }
       }
 
@@ -363,13 +364,13 @@ class ReplServerTests extends AnyWordSpec with Matchers {
         "work for simple case" in Fixture() { url =>
           val response = postQuerySync(url, "1")
           response.obj.keySet should contain("success")
-          response("stdout").str shouldBe "val res0: Int = 1\n"
+          response("stdout").str should include("val res0: Int = 1")
         }
 
         "using predef code" in Fixture("val predefCode = 2") { url =>
           val response = postQuerySync(url, "val foo = predefCode + 40")
           response.obj.keySet should contain("success")
-          response("stdout").str shouldBe "val foo: Int = 42\n"
+          response("stdout").str should include("val foo: Int = 42")
         }
 
         "fail for invalid auth" in Fixture() { url =>
@@ -430,6 +431,8 @@ object Fixture {
     predefCode: String = "",
     runBeforeCode: Seq[String] = Seq.empty,
     runAfterCode: Seq[String] = Seq.empty)(urlToResult: String => T): T = {
+
+    val runBeforeCode0 = DefaultRunBeforeLines(using Colors.BlackWhite) ++ globalRunBeforeLines ++ runBeforeCode
     val additionalClasspathEntryMaybe: Option[Path] =
       if (predefCode.trim.isEmpty) None
       else {
@@ -440,7 +443,8 @@ object Fixture {
         Files.delete(predefFile)
         predefClassfiles.toOption
       }
-    val embeddedRepl = new EmbeddedRepl(compilerArgs(additionalClasspathEntryMaybe), runBeforeCode, runAfterCode)
+
+    val embeddedRepl = new EmbeddedRepl(compilerArgs(additionalClasspathEntryMaybe), runBeforeCode0, runAfterCode, verbose = true)
 
     val host = "localhost"
     val port = 8081