Fix conflicts when watch and interactive try to read StdIn, add test

Author: MaciejG604

modules/cli/src/main/scala/scala/cli/commands/WatchUtil.scala

@@ -1,6 +1,7 @@
 package scala.cli.commands
 
 import scala.annotation.tailrec
+import scala.build.internal.StdInConcurrentReader
 import scala.build.internal.util.ConsoleUtils.ScalaCliConsole
 
 object WatchUtil {
@@ -35,7 +36,7 @@ object WatchUtil {
  @tailrec
  def readNextChar(): Int =
  if (shouldReadInput())
- try System.in.read()
+ try StdInConcurrentReader.waitForLine().map(s => (s + '\n').head.toInt).getOrElse(-1)
  catch {
  case _: InterruptedException =>
  // Actually never called, as System.in.read isn't interruptible…

modules/cli/src/main/scala/scala/cli/commands/run/Run.scala

@@ -225,9 +225,23 @@ object Run extends ScalaCommand[RunOptions] with BuildCommandHelpers {
  )
 
  if (options.sharedRun.watch.watchMode) {
- var processOpt = Option.empty[(Process, CompletableFuture[_])]
+
+ /** A handle to the Runner process, used to kill the process if it's still alive when a change
+ * occured and restarts are allowed or to wait for it if restarts are not allowed
+ */
+ var processOpt = Option.empty[(Process, CompletableFuture[_])]
+
+ /** shouldReadInput controls whether [[WatchUtil.waitForCtrlC]](that's keeping the main thread
+ * alive) should try to read StdIn or just call wait()
+ */
  var shouldReadInput = false
- var mainThreadOpt = Option.empty[Thread]
+
+ /** a handle to the main thread to interrupt its operations when:
+ * - it's blocked on reading StdIn, and it's no longer required
+ * - it's waiting and should start reading StdIn
+ */
+ var mainThreadOpt = Option.empty[Thread]
+
  val watcher = Build.watch(
  inputs,
  initialBuildOptions,

modules/integration/src/test/scala/scala/cli/integration/RunTestDefinitions.scala

@@ -6,6 +6,8 @@ import java.io.{ByteArrayOutputStream, File}
 import java.nio.charset.Charset
 
 import scala.cli.integration.util.DockerServer
+import scala.concurrent.ExecutionContext
+import scala.concurrent.duration.Duration
 import scala.io.Codec
 import scala.jdk.CollectionConverters.*
 import scala.util.Properties
@@ -1393,4 +1395,81 @@ abstract class RunTestDefinitions(val scalaVersionOpt: Option[String])
  expect(output == message)
  }
  }
+
+ test("watch with interactive, with multiple main classes") {
+
+ val fileName = "watch.scala"
+
+ val inputs = TestInputs(
+ os.rel / fileName ->
+ """object Run1 extends App {println("Run1 launched")}
+ |object Run2 extends App {println("Run2 launched")}
+ |""".stripMargin
+ )
+ inputs.fromRoot { root =>
+ os.proc(TestUtil.cli, "config", "interactive")
+ .call(cwd = root)
+
+ os.proc(TestUtil.cli, "config", "interactive-was-suggested")
+ .call(cwd = root)
+
+ val proc = os.proc(TestUtil.cli, "run", "--watch", "--interactive", "watch.scala")
+ .spawn(cwd = root, mergeErrIntoOut = true, stdout = os.Pipe, stdin = os.Pipe)
+
+ try
+ TestUtil.withThreadPool("run-watch-interactive-multi-main-class-test", 2) { pool =>
+ val timeout = Duration("60 seconds")
+ implicit val ec = ExecutionContext.fromExecutorService(pool)
+
+ def linesUntilInteractivePromptIter =
+ Iterator.continually(TestUtil.readLine(proc.stdout, ec, timeout))
+ .takeWhile(!_.contains("[1] Run" /* probably [1] Run2 */ ))
+
+ def linesUntilWatchPromptIter =
+ Iterator.continually(TestUtil.readLine(proc.stdout, ec, timeout))
+ .takeWhile(!_.contains("press Enter to re-run"))
+
+ def checkLinesForError(lines: Seq[String]) = munit.Assertions.assert(
+ !lines.exists { line =>
+ TestUtil.removeAnsiColors(line).contains("[error]")
+ },
+ clues(lines.toSeq)
+ )
+
+ val firstInteractivePromptLines = linesUntilInteractivePromptIter.toList
+ expect(firstInteractivePromptLines.nonEmpty)
+ checkLinesForError(firstInteractivePromptLines)
+ proc.stdin.write("0\n")
+ proc.stdin.flush()
+ expect(TestUtil.readLine(proc.stdout, ec, timeout) == "Run1 launched")
+
+ val firstWatchPromptLines = linesUntilWatchPromptIter.toList
+ expect(firstWatchPromptLines.nonEmpty)
+ checkLinesForError(firstWatchPromptLines)
+ proc.stdin.write("\n")
+ proc.stdin.flush()
+
+ val secondInteractivePromptLines = linesUntilInteractivePromptIter.toList
+ expect(secondInteractivePromptLines.nonEmpty)
+ checkLinesForError(secondInteractivePromptLines)
+ proc.stdin.write("1\n")
+ proc.stdin.flush()
+ expect(TestUtil.readLine(proc.stdout, ec, timeout) == "Run2 launched")
+
+ val secondWatchPromptLines = linesUntilWatchPromptIter.toList
+ expect(secondWatchPromptLines.nonEmpty)
+ checkLinesForError(secondWatchPromptLines)
+ proc.stdin.write("\n")
+ proc.stdin.flush()
+ }
+ finally
+ if (proc.isAlive()) {
+ proc.destroy()
+ Thread.sleep(200L)
+ if (proc.isAlive())
+ proc.destroyForcibly()
+ }
+ }
+ }
+
 }

modules/options/src/main/scala/scala/build/interactive/Interactive.scala

@@ -1,6 +1,6 @@
 package scala.build.interactive
 
-import scala.io.StdIn
+import scala.build.internal.StdInConcurrentReader
 
 sealed abstract class Interactive extends Product with Serializable {
  def confirmOperation(msg: String): Option[Boolean] = None
@@ -16,7 +16,7 @@ object Interactive {
  private def readLine(): String =
  interactiveInputsOpt match {
  case None =>
- StdIn.readLine()
+ StdInConcurrentReader.waitForLine().getOrElse("")
  case Some(interactiveInputs) =>
  synchronized {
  interactiveInputs match {
@@ -35,10 +35,7 @@ object Interactive {
  private sealed abstract class Action[V] extends Product with Serializable {
  def msg: String
  def action: Option[V]
- final def run: Option[V] =
- if (interactiveInputsOpt.nonEmpty || coursier.paths.Util.useAnsiOutput())
- action
- else None
+ final def run: Option[V] = action
  }
 
  private case class ConfirmOperation(msg: String) extends Action[Boolean] {

modules/options/src/main/scala/scala/build/internal/StdInConcurrentReader.scala

@@ -0,0 +1,28 @@
+package scala.build.internal
+
+import java.util.concurrent.atomic.AtomicReference
+
+import scala.concurrent.duration.Duration
+import scala.concurrent.{Await, ExecutionContext, Future}
+import scala.io.StdIn
+
+object StdInConcurrentReader {
+ implicit val ec: ExecutionContext = ExecutionContext.global
+ val readLineFuture: AtomicReference[Future[Option[String]]] =
+ new AtomicReference(Future.successful(None))
+
+ /** Wait for a line to be read from StdIn
+ *
+ * @param atMost
+ * duration to wait before timeout
+ * @return
+ * a line from StdIn wrapped in Some or None if end of stream was reached
+ */
+ def waitForLine(atMost: Duration = Duration.Inf): Option[String] = {
+ val updatedFuture = readLineFuture.updateAndGet { f =>
+ if f.isCompleted then Future(Option(StdIn.readLine())) else f
+ }
+
+ Await.result(updatedFuture, atMost)
+ }
+}