Merge pull request #1727 from alexarchambault/watch-artifacts-for-changes

Watch artifacts for changes

Author: alexarchambault

modules/build/src/main/scala/scala/build/Build.scala

@@ -675,11 +675,13 @@ object Build {
       val elements: Seq[Element] =
         if (res == null) inputs.elements
         else
-          res.map { builds =>
-            val mainElems = builds.main.inputs.elements
-            val testElems = builds.get(Scope.Test).map(_.inputs.elements).getOrElse(Nil)
-            (mainElems ++ testElems).distinct
-          }.getOrElse(inputs.elements)
+          res
+            .map { builds =>
+              val mainElems = builds.main.inputs.elements
+              val testElems = builds.get(Scope.Test).map(_.inputs.elements).getOrElse(Nil)
+              (mainElems ++ testElems).distinct
+            }
+            .getOrElse(inputs.elements)
       for (elem <- elements) {
         val depth = elem match {
           case _: SingleFile => -1
@@ -711,6 +713,26 @@ object Build {
           }
         }
       }
+
+      val artifacts = res
+        .map { builds =>
+          def artifacts(build: Build): Seq[os.Path] =
+            build.successfulOpt.toSeq.flatMap(_.artifacts.classPath)
+          val main = artifacts(builds.main)
+          val test = builds.get(Scope.Test).map(artifacts).getOrElse(Nil)
+          (main ++ test).distinct
+        }
+        .getOrElse(Nil)
+      for (artifact <- artifacts) {
+        val depth    = if (os.isFile(artifact)) -1 else Int.MaxValue
+        val watcher0 = watcher.newWatcher()
+        watcher0.register(artifact.toNIO, depth)
+        watcher0.addObserver {
+          onChangeBufferedObserver { _ =>
+            watcher.schedule()
+          }
+        }
+      }
     }
 
     try doWatch()

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

@@ -3,8 +3,8 @@ package scala.cli.integration
 import com.eed3si9n.expecty.Expecty.expect
 
 import scala.cli.integration.util.BloopUtil
+import scala.concurrent.ExecutionContext
 import scala.concurrent.duration.Duration
-import scala.concurrent.{Await, ExecutionContext, Future}
 
 class BloopTests extends ScalaCliSuite {
 
@@ -144,13 +144,8 @@ class BloopTests extends ScalaCliSuite {
   test("Restart Bloop server while watching") {
     TestUtil.withThreadPool("bloop-restart-test", 2) { pool =>
       val timeout = Duration("20 seconds")
-      def readLine(stream: os.SubProcess.OutputStream): String = {
-        implicit val ec = ExecutionContext.fromExecutorService(pool)
-        val readLineF = Future {
-          stream.readLine()
-        }
-        Await.result(readLineF, timeout)
-      }
+      val ec      = ExecutionContext.fromExecutorService(pool)
+
       def content(message: String) =
         s"""object Hello {
            |  def main(args: Array[String]): Unit =
@@ -164,14 +159,14 @@ class BloopTests extends ScalaCliSuite {
       inputs.fromRoot { root =>
         val proc = os.proc(TestUtil.cli, "run", "-w", ".")
           .spawn(cwd = root)
-        val firstLine = readLine(proc.stdout)
+        val firstLine = TestUtil.readLine(proc.stdout, ec, timeout)
         expect(firstLine == "Hello")
 
         os.proc(TestUtil.cli, "bloop", "exit")
           .call(cwd = root)
 
         os.write.over(root / sourcePath, content("Foo"))
-        val secondLine = readLine(proc.stdout)
+        val secondLine = TestUtil.readLine(proc.stdout, ec, timeout)
         expect(secondLine == "Foo")
 
         proc.destroy()

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

@@ -2,6 +2,8 @@ package scala.cli.integration
 
 import com.eed3si9n.expecty.Expecty.expect
 
+import scala.concurrent.ExecutionContext
+import scala.concurrent.duration.Duration
 import scala.util.Properties
 
 class RunTestsDefault extends RunTestDefinitions(scalaVersionOpt = None) {
@@ -64,4 +66,67 @@ class RunTestsDefault extends RunTestDefinitions(scalaVersionOpt = None) {
     }
   }
 
+  test("watch artifacts") {
+    val libSourcePath = os.rel / "lib" / "Messages.scala"
+    def libSource(hello: String) =
+      s"""//> using publish.organization "test-org"
+         |//> using publish.name "messages"
+         |//> using publish.version "0.1.0"
+         |
+         |package messages
+         |
+         |object Messages {
+         |  def hello(name: String) = s"$hello $$name"
+         |}
+         |""".stripMargin
+    val inputs = TestInputs(
+      libSourcePath -> libSource("Hello"),
+      os.rel / "app" / "TestApp.scala" ->
+        """//> using lib "test-org::messages:0.1.0"
+          |
+          |package testapp
+          |
+          |import messages.Messages
+          |
+          |@main
+          |def run(): Unit =
+          |  println(Messages.hello("user"))
+          |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val testRepo = root / "test-repo"
+
+      def publishLib(): Unit =
+        os.proc(TestUtil.cli, "publish", "--publish-repo", testRepo, "lib")
+          .call(cwd = root)
+
+      publishLib()
+
+      val proc = os.proc(TestUtil.cli, "run", "app", "-w", "-r", testRepo.toNIO.toUri.toASCIIString)
+        .spawn(cwd = root)
+
+      try
+        TestUtil.withThreadPool("watch-artifacts-test", 2) { pool =>
+          val timeout = Duration("20 seconds")
+          val ec      = ExecutionContext.fromExecutorService(pool)
+
+          val output = TestUtil.readLine(proc.stdout, ec, timeout)
+          expect(output == "Hello user")
+
+          os.write.over(root / libSourcePath, libSource("Hola"))
+          publishLib()
+
+          val secondOutput = TestUtil.readLine(proc.stdout, ec, timeout)
+          expect(secondOutput == "Hola user")
+        }
+      finally
+        if (proc.isAlive()) {
+          proc.destroy()
+          Thread.sleep(200L)
+          if (proc.isAlive())
+            proc.destroyForcibly()
+        }
+    }
+  }
+
 }

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

@@ -8,6 +8,7 @@ import java.util.concurrent.{ExecutorService, Executors, ScheduledExecutorServic
 
 import scala.annotation.tailrec
 import scala.concurrent.duration.{Duration, DurationInt, FiniteDuration}
+import scala.concurrent.{Await, ExecutionContext, Future}
 import scala.util.Properties
 
 object TestUtil {
@@ -259,4 +260,16 @@ object TestUtil {
     }
     Map(pathVarName -> s"$binDir${File.pathSeparator}$currentPath")
   }
+
+  def readLine(
+    stream: os.SubProcess.OutputStream,
+    ec: ExecutionContext,
+    timeout: Duration
+  ): String = {
+    implicit val ec0 = ec
+    val readLineF = Future {
+      stream.readLine()
+    }
+    Await.result(readLineF, timeout)
+  }
 }