[autofix.ci] apply automated fixes

Author: autofix-ci[bot]

main/util/src/mill/util/Watchable.scala

@@ -10,6 +10,7 @@ import mill.api.internal
  */
 @internal
 private[mill] trait Watchable {
+
   /** @return the hashcode of a watched value. */
   def poll(): Long
 

runner/src/mill/runner/MillCliConfig.scala

@@ -97,7 +97,8 @@ case class MillCliConfig(
     watch: Flag = Flag(),
     @arg(
       name = "watch-via-fs-notify",
-      doc = "Use filesystem based file watching instead of polling based one (experimental, defaults to false).",
+      doc =
+        "Use filesystem based file watching instead of polling based one (experimental, defaults to false)."
     )
     watchViaFsNotify: Boolean = false,
     @arg(

runner/src/mill/runner/MillMain.scala

@@ -232,7 +232,10 @@ object MillMain {
                     val (isSuccess, evalStateOpt) = Watching.watchLoop(
                       ringBell = config.ringBell.value,
                       watch = Option.when(config.watch.value)(Watching.WatchArgs(
-                        setIdle, colors, useNotify = config.watchViaFsNotify, serverDir = serverDir
+                        setIdle,
+                        colors,
+                        useNotify = config.watchViaFsNotify,
+                        serverDir = serverDir
                       )),
                       streams = streams,
                       evaluate = (enterKeyPressed: Boolean, prevState: Option[RunnerState]) => {

runner/src/mill/runner/Watching.scala

@@ -122,68 +122,78 @@ object Watching {
       enterKeyPressed
     }
 
-    if (useNotify) Using.resource(os.write.outputStream(serverDir / "fsNotifyWatchLog")) { watchLog =>
-      def writeToWatchLog(s: String): Unit = {
-        watchLog.write(s.getBytes(java.nio.charset.StandardCharsets.UTF_8))
-        watchLog.write('\n')
-      }
+    if (useNotify)
+      Using.resource(os.write.outputStream(serverDir / "fsNotifyWatchLog")) { watchLog =>
+        def writeToWatchLog(s: String): Unit = {
+          watchLog.write(s.getBytes(java.nio.charset.StandardCharsets.UTF_8))
+          watchLog.write('\n')
+        }
 
-      @volatile var pathChangesDetected = false
+        @volatile var pathChangesDetected = false
 
-      // oslib watch only works with folders, so we have to watch the parent folders instead
+        // oslib watch only works with folders, so we have to watch the parent folders instead
 
-      writeToWatchLog(s"[watched-paths:unfiltered] ${watchedPathsSet.toSeq.sorted.mkString("\n")}")
+        writeToWatchLog(
+          s"[watched-paths:unfiltered] ${watchedPathsSet.toSeq.sorted.mkString("\n")}"
+        )
 
-      val workspaceRoot = mill.api.WorkspaceRoot.workspaceRoot
+        val workspaceRoot = mill.api.WorkspaceRoot.workspaceRoot
 
-      /** Paths that are descendants of [[workspaceRoot]]. */
-      val pathsUnderWorkspaceRoot = watchedPathsSet.filter { path =>
-        val isUnderWorkspaceRoot = path.startsWith(workspaceRoot)
-        if (!isUnderWorkspaceRoot) {
-          streams.err.println(colors.error(
-            s"Watched path $path is outside workspace root $workspaceRoot, this is unsupported."
-          ).toString())
-        }
+        /** Paths that are descendants of [[workspaceRoot]]. */
+        val pathsUnderWorkspaceRoot = watchedPathsSet.filter { path =>
+          val isUnderWorkspaceRoot = path.startsWith(workspaceRoot)
+          if (!isUnderWorkspaceRoot) {
+            streams.err.println(colors.error(
+              s"Watched path $path is outside workspace root $workspaceRoot, this is unsupported."
+            ).toString())
+          }
 
-        isUnderWorkspaceRoot
-      }
+          isUnderWorkspaceRoot
+        }
 
-      // If I have 'root/a/b/c'
-      //
-      // Then I want to watch:
-      //   root/a/b/c
-      //   root/a/b
-      //   root/a
-      //   root
-      val filterPaths = pathsUnderWorkspaceRoot.flatMap { path =>
-        path.relativeTo(workspaceRoot).segments.inits.map(segments => workspaceRoot / segments)
-      }
-      writeToWatchLog(s"[watched-paths:filtered] ${filterPaths.toSeq.sorted.mkString("\n")}")
-
-      Using.resource(os.watch.watch(
-        // Just watch the root folder
-        Seq(workspaceRoot),
-        filter = path => {
-          val shouldBeWatched =
-            filterPaths.contains(path) || watchedPathsSet.exists(watchedPath => path.startsWith(watchedPath))
-          writeToWatchLog(s"[filter] (shouldBeWatched=$shouldBeWatched) $path")
-          shouldBeWatched
-        },
-        onEvent = changedPaths => {
-          // Make sure that the changed paths are actually the ones in our watch list and not some adjacent files in the
-          // same folder
-          val hasWatchedPath =
-            changedPaths.exists(p => watchedPathsSet.exists(watchedPath => p.startsWith(watchedPath)))
-          writeToWatchLog(s"[changed-paths] (hasWatchedPath=$hasWatchedPath) ${changedPaths.mkString("\n")}")
-          if (hasWatchedPath) {
-            pathChangesDetected = true
-          }
-        },
-        logger = (eventType, data) => writeToWatchLog(s"[watch:event] $eventType: ${pprint.apply(data).plainText}")
-      )) { _ =>
-        doWatch(notifiablesChanged = () => pathChangesDetected)
+        // If I have 'root/a/b/c'
+        //
+        // Then I want to watch:
+        //   root/a/b/c
+        //   root/a/b
+        //   root/a
+        //   root
+        val filterPaths = pathsUnderWorkspaceRoot.flatMap { path =>
+          path.relativeTo(workspaceRoot).segments.inits.map(segments => workspaceRoot / segments)
+        }
+        writeToWatchLog(s"[watched-paths:filtered] ${filterPaths.toSeq.sorted.mkString("\n")}")
+
+        Using.resource(os.watch.watch(
+          // Just watch the root folder
+          Seq(workspaceRoot),
+          filter = path => {
+            val shouldBeWatched =
+              filterPaths.contains(path) || watchedPathsSet.exists(watchedPath =>
+                path.startsWith(watchedPath)
+              )
+            writeToWatchLog(s"[filter] (shouldBeWatched=$shouldBeWatched) $path")
+            shouldBeWatched
+          },
+          onEvent = changedPaths => {
+            // Make sure that the changed paths are actually the ones in our watch list and not some adjacent files in the
+            // same folder
+            val hasWatchedPath =
+              changedPaths.exists(p =>
+                watchedPathsSet.exists(watchedPath => p.startsWith(watchedPath))
+              )
+            writeToWatchLog(
+              s"[changed-paths] (hasWatchedPath=$hasWatchedPath) ${changedPaths.mkString("\n")}"
+            )
+            if (hasWatchedPath) {
+              pathChangesDetected = true
+            }
+          },
+          logger = (eventType, data) =>
+            writeToWatchLog(s"[watch:event] $eventType: ${pprint.apply(data).plainText}")
+        )) { _ =>
+          doWatch(notifiablesChanged = () => pathChangesDetected)
+        }
       }
-    }
     else {
       doWatch(notifiablesChanged = () => watchedPathsSeq.exists(p => !p.validate()))
     }