Merge pull request #6870 from eatkins/watch-on-termination

Restore watchOnTermination callbacks

main/src/main/scala/sbt/internal/Continuous.scala

@@ -1128,7 +1128,28 @@ private[sbt] object Continuous extends DeprecatedContinuous {
       val callbacks: Callbacks,
       val dynamicInputs: mutable.Set[DynamicInput],
       val pending: Boolean,
+      var failAction: Option[Watch.Action],
   ) {
+    def this(
+        count: Int,
+        commands: Seq[String],
+        beforeCommandImpl: (State, mutable.Set[DynamicInput]) => State,
+        afterCommand: State => State,
+        afterWatch: State => State,
+        callbacks: Callbacks,
+        dynamicInputs: mutable.Set[DynamicInput],
+        pending: Boolean,
+    ) = this(
+      count,
+      commands,
+      beforeCommandImpl,
+      afterCommand,
+      afterWatch,
+      callbacks,
+      dynamicInputs,
+      pending,
+      None
+    )
     def beforeCommand(state: State): State = beforeCommandImpl(state, dynamicInputs)
     def incremented: ContinuousState = withCount(count + 1)
     def withPending(p: Boolean) =
@@ -1323,7 +1344,8 @@ private[sbt] object ContinuousCommands {
         case Watch.Prompt => stop.map(_ :: s"$PromptChannel ${channel.name}" :: Nil mkString ";")
         case Watch.Run(commands) =>
           stop.map(_ +: commands.map(_.commandLine).filter(_.nonEmpty) mkString "; ")
-        case Watch.HandleError(_) =>
+        case a @ Watch.HandleError(_) =>
+          cs.failAction = Some(a)
           stop.map(_ :: s"$failWatch ${channel.name}" :: Nil mkString "; ")
         case _ => stop
       }
@@ -1353,7 +1375,8 @@ private[sbt] object ContinuousCommands {
     }
     cs.afterCommand(postState)
   }
-  private[sbt] val stopWatchCommand = watchCommand(stopWatch) { (channel, state) =>
+  private[this] val exitWatchShared = (error: Boolean) =>
+    (channel: String, state: State) =>
       state.get(watchStates).flatMap(_.get(channel)) match {
         case Some(cs) =>
           val afterWatchState = cs.afterWatch(state)
@@ -1364,16 +1387,19 @@ private[sbt] object ContinuousCommands {
               c.terminal.setPrompt(Prompt.Pending)
               c.unprompt(ConsoleUnpromptEvent(Some(CommandSource(channel))))
             }
-        afterWatchState.get(watchStates) match {
+          val newState = afterWatchState.get(watchStates) match {
             case None    => afterWatchState
             case Some(w) => afterWatchState.put(watchStates, w - channel)
           }
-      case _ => state
+          val commands = cs.commands.mkString("; ")
-    }
+          val count = cs.count
-  }
+          val action = cs.failAction.getOrElse(Watch.CancelWatch)
-  private[sbt] val failWatchCommand = watchCommand(failWatch) { (channel, state) =>
+          val st = cs.callbacks.onTermination(action, commands, count, newState)
-    state.fail
+          if (error) st.fail else st
+        case _ => if (error) state.fail else state
       }
+  private[sbt] val stopWatchCommand = watchCommand(stopWatch)(exitWatchShared(false))
+  private[sbt] val failWatchCommand = watchCommand(failWatch)(exitWatchShared(true))
   /*
    * Creates a FileTreeRepository where it is safe to call close without inadvertently cancelling
    * still active watches.

sbt-app/src/sbt-test/watch/on-error/build.sbt

@@ -0,0 +1,3 @@
+import sbt.watch.task.Build
+
+val root = Build.root

sbt-app/src/sbt-test/watch/on-error/test

@@ -0,0 +1,7 @@
+# This tests that we can override the state transformation in the watch task
+# In the build, watchOnEvent should return CancelWatch which should be successful, but we
+# override watchTasks to fail the state instead
+
+-> ~ root / setStringValue foo.txt bar
+
+> checkStringValue foo.txt bar

sbt-app/src/sbt-test/watch/on-termination/build.sbt

@@ -1,3 +1,15 @@
-import sbt.watch.task.Build
+watchOnIteration := { (count, project, commands) =>
-
+  Watch.CancelWatch
-val root = Build.root
+}
+watchOnTermination := { (action, count, command, state) =>
+  action match {
+    case Watch.CancelWatch =>
+      java.nio.file.Files.delete(java.nio.file.Paths.get("foo.txt"))
+    case Watch.HandleError(e) =>
+      if (e.getMessage == "fail")
+        java.nio.file.Files.delete(java.nio.file.Paths.get("bar.txt"))
+      else
+        throw new IllegalStateException("unexpected error")
+  }
+  state
+}

sbt-app/src/sbt-test/watch/on-termination/test

@@ -1,7 +1,8 @@
-# This tests that we can override the state transformation in the watch task
+$ exists foo.txt
-# In the build, watchOnEvent should return CancelWatch which should be successful, but we
+> ~compile
-# override watchTasks to fail the state instead
+$ absent foo.txt
+> set watchOnIteration := { (_, _, _) => new Watch.HandleError(new IllegalStateException("fail")) }
+$ exists bar.txt
+-> ~compile
+$ absent bar.txt
 
--> ~ root / setStringValue foo.txt bar
-
-> checkStringValue foo.txt bar