server-mode-rewrite: squashed

slf4j-simple for stage

WIP

refactor WebServiceWithWebSocket: style

reimplement server mode

* previously it was a very flakey since it just piped input/output
streams and would fail for a random 'println' in the code or inherited
code
* It pretended to handle concurrent requests which was a lie. Now
we're programmatically interacting with the ReplDriver
* No more manual thread handling, killing of the process etc.

refactor for reuse and DRY: server.ReplDriver and ReplDriver

refactor: shuffle classes around

more refactorings, including optional server auth handling

fix and refactor ReplServerTests

add test for predefined code, refactor some of the test code

test synchronous api

readme

refactor

EmbeddedReplTests: fixup

Author: mpollmeier

README.md

@@ -264,7 +264,43 @@ The prefix is arbitrary and is only used to specify several credentials in a sin
 ./scala-repl-pp --server
 
 curl http://localhost:8080/query-sync -X POST -d '{"query": "val foo = 42"}'
+# {"success":true,"stdout":"val foo: Int = 42\n",...}
+
 curl http://localhost:8080/query-sync -X POST -d '{"query": "val bar = foo + 1"}'
+# {"success":true,"stdout":"val bar: Int = 43\n",...}
+
+curl http://localhost:8080/query-sync -X POST -d '{"query":"println(\"OMG remote code execution!!1!\")"}'
+# {"success":true,"stdout":"",...}%
+```
+
+Predef code works with server as well:
+```
+echo val foo = 99 > foo.sc
+./scala-repl-pp --server --predef foo.sc
+
+curl -XPOST http://localhost:8080/query-sync -d '{"query":"val baz = foo + 1"}'
+# {"success":true,"stdout":"val baz: Int = 100\n",...}
+```
+
+There's also has an asynchronous mode:
+```
+./scala-repl-pp --server
+
+curl http://localhost:8080/query -X POST -d '{"query": "val baz = 93"}'
+# {"success":true,"uuid":"e2640fcb-3193-4386-8e05-914b639c3184"}%
+
+curl http://localhost:8080/result/e2640fcb-3193-4386-8e05-914b639c3184
+{"success":true,"uuid":"e2640fcb-3193-4386-8e05-914b639c3184","stdout":"val baz: Int = 93\n"}%
+```
+
+And there's even a websocket channel that allows you to get notified when the query has finished. For more details and other use cases check out [ReplServerTests.scala](server/src/test/scala/replpp/server/ReplServerTests.scala)
+
+Server-specific configuration options as per `scala-repl-pp --help`:
+```
+--server-host <value>    Hostname on which to expose the REPL server
+--server-port <value>    Port on which to expose the REPL server
+--server-auth-username <value> Basic auth username for the REPL server
+--server-auth-password <value> Basic auth password for the REPL server
 ```
 
 ## Embed into your own project

build.sbt

@@ -38,7 +38,10 @@ lazy val server = project.in(file("server"))
 lazy val all = project.in(file("all"))
   .dependsOn(core, server)
   .enablePlugins(JavaAppPackaging)
-  .settings(name := "scala-repl-pp-all")
+  .settings(
+    name := "scala-repl-pp-all",
+    libraryDependencies += "org.slf4j" % "slf4j-simple" % "2.0.7" % Optional,
+  )
 
 ThisBuild / libraryDependencies ++= Seq(
   "org.scalatest" %% "scalatest" % ScalaTestVersion % Test,

core/src/main/scala/replpp/Config.scala

@@ -24,8 +24,8 @@ case class Config(
   server: Boolean = false,
   serverHost: String = "localhost",
   serverPort: Int = 8080,
-  serverAuthUsername: String = "",
-  serverAuthPassword: String = "",
+  serverAuthUsername: Option[String] = None,
+  serverAuthPassword: Option[String] = None,
 ) {
   /** inverse of `Config.parse` */
   lazy val asJavaArgs: Seq[String] = {
@@ -154,11 +154,11 @@ object Config {
         .text("Port on which to expose the REPL server")
 
       opt[String]("server-auth-username")
-        .action((x, c) => c.copy(serverAuthUsername = x))
+        .action((x, c) => c.copy(serverAuthUsername = Option(x)))
         .text("Basic auth username for the REPL server")
 
       opt[String]("server-auth-password")
-        .action((x, c) => c.copy(serverAuthPassword = x))
+        .action((x, c) => c.copy(serverAuthPassword = Option(x)))
         .text("Basic auth password for the REPL server")
 
       help("help")

core/src/main/scala/replpp/ReplDriver.scala

@@ -28,7 +28,7 @@ class ReplDriver(args: Array[String],
                  greeting: Option[String],
                  prompt: String,
                  maxHeight: Option[Int] = None,
-                 classLoader: Option[ClassLoader] = None) extends dotty.tools.repl.ReplDriver(args, out, classLoader) {
+                 classLoader: Option[ClassLoader] = None) extends ReplDriverBase(args, out, classLoader) {
 
   /** Run REPL with `state` until `:quit` command found
     * Main difference to the 'original': different greeting, trap Ctrl-c
@@ -82,43 +82,4 @@ class ReplDriver(args: Array[String],
     terminal.readLine(completer).linesIterator
   }
 
-  private def interpretInput(lines: IterableOnce[String], state: State, currentFile: Path): State = {
-    val parsedLines = Seq.newBuilder[String]
-    var resultingState = state
-
-    def handleImportFileDirective(line: String) = {
-      val linesBeforeUsingFileDirective = parsedLines.result()
-      parsedLines.clear()
-      if (linesBeforeUsingFileDirective.nonEmpty) {
-        // interpret everything until here
-        val parseResult = parseInput(linesBeforeUsingFileDirective, resultingState)
-        resultingState = interpret(parseResult)(using resultingState)
-      }
-
-      // now read and interpret the given file
-      val pathStr = line.trim.drop(UsingDirectives.FileDirective.length)
-      val path = resolveFile(currentFile, pathStr)
-      val linesFromFile = util.linesFromFile(path)
-      println(s"> importing $path (${linesFromFile.size} lines)")
-      resultingState = interpretInput(linesFromFile, resultingState, path)
-    }
-
-    for (line <- lines.iterator) {
-      if (line.trim.startsWith(UsingDirectives.FileDirective))
-        handleImportFileDirective(line)
-      else
-        parsedLines.addOne(line)
-    }
-
-    val parseResult = parseInput(parsedLines.result(), resultingState)
-    resultingState = interpret(parseResult)(using resultingState)
-    resultingState
-  }
-
-  private def parseInput(lines: IterableOnce[String], state: State): ParseResult =
-    parseInput(lines.iterator.mkString(lineSeparator), state)
-
-  private def parseInput(input: String, state: State): ParseResult =
-    ParseResult(input)(using state)
-
 }

core/src/main/scala/replpp/ReplDriverBase.scala

@@ -0,0 +1,67 @@
+package replpp
+
+import dotty.tools.MainGenericCompiler.classpathSeparator
+import dotty.tools.dotc.Run
+import dotty.tools.dotc.ast.{Positioned, tpd, untpd}
+import dotty.tools.dotc.classpath.{AggregateClassPath, ClassPathFactory}
+import dotty.tools.dotc.config.{Feature, JavaPlatform, Platform}
+import dotty.tools.dotc.core.Comments.{ContextDoc, ContextDocstrings}
+import dotty.tools.dotc.core.Contexts.{Context, ContextBase, ContextState, FreshContext, ctx, explore}
+import dotty.tools.dotc.core.{Contexts, MacroClassLoader, Mode, TyperState}
+import dotty.tools.io.{AbstractFile, ClassPath, ClassRepresentation}
+import dotty.tools.repl.*
+import org.jline.reader.*
+import org.slf4j.{Logger, LoggerFactory}
+
+import java.io.PrintStream
+import java.lang.System.lineSeparator
+import java.net.URL
+import java.nio.file.Path
+import javax.naming.InitialContext
+import scala.annotation.tailrec
+import scala.collection.mutable
+import scala.jdk.CollectionConverters.*
+import scala.util.{Failure, Success, Try}
+
+abstract class ReplDriverBase(args: Array[String], out: PrintStream, classLoader: Option[ClassLoader])
+  extends dotty.tools.repl.ReplDriver(args, out, classLoader) {
+
+  protected def interpretInput(lines: IterableOnce[String], state: State, currentFile: Path): State = {
+    val parsedLines = Seq.newBuilder[String]
+    var currentState = state
+
+    def handleImportFileDirective(line: String) = {
+      val linesBeforeUsingFileDirective = parsedLines.result()
+      parsedLines.clear()
+      if (linesBeforeUsingFileDirective.nonEmpty) {
+        // interpret everything until here
+        val parseResult = parseInput(linesBeforeUsingFileDirective, currentState)
+        currentState = interpret(parseResult)(using currentState)
+      }
+
+      // now read and interpret the given file
+      val pathStr = line.trim.drop(UsingDirectives.FileDirective.length)
+      val path = resolveFile(currentFile, pathStr)
+      val linesFromFile = util.linesFromFile(path)
+      println(s"> importing $path (${linesFromFile.size} lines)")
+      currentState = interpretInput(linesFromFile, currentState, path)
+    }
+
+    for (line <- lines.iterator) {
+      if (line.trim.startsWith(UsingDirectives.FileDirective))
+        handleImportFileDirective(line)
+      else
+        parsedLines.addOne(line)
+    }
+
+    val parseResult = parseInput(parsedLines.result(), currentState)
+    interpret(parseResult)(using currentState)
+  }
+
+  private def parseInput(lines: IterableOnce[String], state: State): ParseResult =
+    parseInput(lines.iterator.mkString(lineSeparator), state)
+
+  private def parseInput(input: String, state: State): ParseResult =
+    ParseResult(input)(using state)
+
+}

core/src/main/scala/replpp/package.scala

@@ -80,7 +80,7 @@ package object replpp {
   def allPredefCode(config: Config): String =
     allPredefLines(config).mkString(lineSeparator)
 
-  private def allPredefLines(config: Config): Seq[String] = {
+  def allPredefLines(config: Config): Seq[String] = {
     val resultLines = Seq.newBuilder[String]
     val visited = mutable.Set.empty[Path]
 

server/src/it/scala/replpp/server/EmbeddedReplTests.scala

@@ -2,8 +2,8 @@ package replpp.server
 
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpec
-
-import java.util.concurrent.Semaphore
+import scala.concurrent.Await
+import scala.concurrent.duration.Duration
 
 /** Moved to IntegrationTests, because of some strange interaction with ReplServerTests:
   * if EmbeddedReplTests would run *before* ReplServerTests, the latter would stall (forever)
@@ -12,34 +12,21 @@ import java.util.concurrent.Semaphore
   */
 class EmbeddedReplTests extends AnyWordSpec with Matchers {
 
-  "start and shutdown without hanging" in {
-    val shell = new EmbeddedRepl()
-    shell.start()
-    shell.shutdown()
-  }
-
   "execute commands synchronously" in {
-    val shell = new EmbeddedRepl()
-    shell.start()
+    val repl = new EmbeddedRepl()
 
-    shell.query("val x = 0").out shouldBe "val x: Int = 0\n"
-    shell.query("x + 1").out     shouldBe "val res1: Int = 1\n"
+    repl.query("val x = 0").output shouldBe "val x: Int = 0\n"
+    repl.query("x + 1").output     shouldBe "val res0: Int = 1\n"
 
-    shell.shutdown()
+    repl.shutdown()
   }
 
-   "execute a command asynchronously" in {
-     val shell = new EmbeddedRepl()
-     val mutex = new Semaphore(0)
-     shell.start()
-     var resultOut = "uninitialized"
-     shell.queryAsync("val x = 0") { result =>
-       resultOut = result.out
-       mutex.release()
-     }
-     mutex.acquire()
-     resultOut shouldBe "val x: Int = 0\n"
-     shell.shutdown()
-   }
+  "execute a command asynchronously" in {
+    val repl = new EmbeddedRepl()
+    val (uuid, futureResult) = repl.queryAsync("val x = 0")
+    val result = Await.result(futureResult, Duration.Inf)
+    result shouldBe "val x: Int = 0\n"
+    repl.shutdown()
+  }
 
 }