Fix exceptional handling for sbt tasks

Author: moznion

plugin/src/main/scala/net/moznion/sbt/SbtSpotless.scala

@@ -21,6 +21,7 @@ import java.io.File
 import com.diffplug.spotless.Provisioner
 import net.moznion.sbt.spotless._
 import net.moznion.sbt.spotless.config._
+import net.moznion.sbt.spotless.exception.FormatException
 import net.moznion.sbt.spotless.task._
 import sbt.Keys._
 import sbt.{Def, _}
@@ -55,8 +56,11 @@ object SbtSpotless extends AutoPlugin {
 
   override def projectSettings: Seq[Def.Setting[_]] =
     super.projectSettings ++ Seq(
-      spotlessCheck := supplySpotlessTaskInitiator(RunningMode(check = true)).value,
-      spotlessApply := supplySpotlessTaskInitiator(RunningMode(check = true, applyFormat = true)).value,
+      spotlessCheck := supplySpotlessTaskInitiator(RunningMode(check = true), "spotlessCheck").value,
+      spotlessApply := supplySpotlessTaskInitiator(
+        RunningMode(check = true, applyFormat = true),
+        "spotlessApply",
+      ).value,
     )
 
   override def globalSettings: Seq[Def.Setting[_]] = Seq(
@@ -69,8 +73,8 @@ object SbtSpotless extends AutoPlugin {
     spotlessSql := SqlConfig(enabled = false),
   )
 
-  private val supplySpotlessTaskInitiator: RunningMode => Def.Initialize[Task[Unit]] = {
-    mode: RunningMode =>
+  private val supplySpotlessTaskInitiator: (RunningMode, String) => Def.Initialize[Task[Unit]] = {
+    (mode: RunningMode, taskName: String) =>
       Def.task {
         val defaultBaseDir: File = thisProject.value.base
         val config: SpotlessConfig = spotless.value
@@ -86,37 +90,59 @@ object SbtSpotless extends AutoPlugin {
           (sources in Compile).value.toList ++ (sources in Test).value.toList
 
         val javaConfig: JavaConfig = spotlessJava.value
+
+        var tasksToRun: Seq[RunnableTask[_]] = Seq()
+
         if (javaConfig.enabled) {
           val javaFiles =
             classPathFiles.filter(p => javaConfig.getExtensions.exists(ext => p.ext.equals(ext)))
-          Java(javaFiles, javaConfig, pathConfig, logger).run(provisioner, mode)
+          tasksToRun :+= Java(javaFiles, javaConfig, pathConfig, logger)
         }
 
         val scalaConfig: ScalaConfig = spotlessScala.value
         if (scalaConfig.enabled) {
           val scalaFiles =
             classPathFiles.filter(p => scalaConfig.getExtensions.exists(ext => p.ext.equals(ext)))
-          Scala(scalaFiles, scalaConfig, pathConfig, logger).run(provisioner, mode)
+          tasksToRun :+= Scala(scalaFiles, scalaConfig, pathConfig, logger)
         }
 
         val cppConfig: CppConfig = spotlessCpp.value
         if (cppConfig.enabled) {
-          Cpp(cppConfig, pathConfig, logger).run(provisioner, mode)
+          tasksToRun :+= Cpp(cppConfig, pathConfig, logger)
         }
 
         val groovyConfig: GroovyConfig = spotlessGroovy.value
         if (groovyConfig.enabled) {
-          Groovy(groovyConfig, pathConfig, logger).run(provisioner, mode)
+          tasksToRun :+= Groovy(groovyConfig, pathConfig, logger)
         }
 
         val kotlinConfig: KotlinConfig = spotlessKotlin.value
         if (kotlinConfig.enabled) {
-          Kotlin(kotlinConfig, pathConfig, logger).run(provisioner, mode)
+          tasksToRun :+= Kotlin(kotlinConfig, pathConfig, logger)
         }
 
         val sqlConfig: SqlConfig = spotlessSql.value
         if (sqlConfig.enabled) {
-          Sql(sqlConfig, pathConfig, logger).run(provisioner, mode)
+          tasksToRun :+= Sql(sqlConfig, pathConfig, logger)
+        }
+
+        val succeeded: Boolean = tasksToRun
+          .map(task =>
+            try {
+              task.run(provisioner, mode)
+              true
+            } catch {
+              case e: FormatException =>
+                logger.error(e.getMessage)
+                false
+            },
+          )
+          .reduce((acc, taskResult) => acc && taskResult)
+
+        if (!succeeded) {
+          throw new MessageOnlyException(
+            s"Failed to run $taskName, please refer to the above logs.",
+          )
         }
       }
   }

plugin/src/main/scala/net/moznion/sbt/spotless/exception/FormatException.scala

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2020 moznion.net
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.moznion.sbt.spotless.exception
+
+abstract class FormatException(message: String) extends Exception(message)

plugin/src/main/scala/net/moznion/sbt/spotless/exception/ShouldTurnOnPaddedCellException.scala

@@ -32,7 +32,7 @@ object ShouldTurnOnPaddedCellException {
        |work around this bug and generate helpful bug reports for the broken rule
        |if you add 'paddedCell = true' to your build.sbt as such:
        |
-       |  ${taskName} := ${configClassName}(
+       |  $taskName := $configClassName(
        |    ...
        |    paddedCell = true,
        |  )
@@ -41,15 +41,15 @@ object ShouldTurnOnPaddedCellException {
        |"${pathConfig.paddedCellDiagnoseDir.toString}", and spotlessApply
        |and spotlessCheck will be self-consistent from here on out.
        |
-       |For details see: ${paddedCellDescriptionURL}""".stripMargin
+       |For details see: $paddedCellDescriptionURL""".stripMargin
 }
 
 case class ShouldTurnOnPaddedCellException(
     private val taskName: String,
     private val configClassName: String,
     private val paddedCellDescriptionURL: String,
     private val pathConfig: SpotlessPathConfig,
-) extends Exception(
+) extends FormatException(
       ShouldTurnOnPaddedCellException
         .message(taskName, configClassName, paddedCellDescriptionURL, pathConfig),
     ) {}

plugin/src/main/scala/net/moznion/sbt/spotless/exception/ViolatedFormatException.scala

@@ -16,4 +16,4 @@
 
 package net.moznion.sbt.spotless.exception
 
-case class ViolatedFormatException(msg: String) extends Exception(msg) {}
+case class ViolatedFormatException(msg: String) extends FormatException(msg) {}

plugin/src/main/scala/net/moznion/sbt/spotless/task/Cpp.scala

@@ -32,10 +32,7 @@ private[sbt] case class Cpp[T <: CppConfig](
     private val pathConfig: SpotlessPathConfig,
     private val logger: Logger,
 ) extends RunnableTask[T] {
-  def run(
-      provisioner: Provisioner,
-      mode: RunningMode,
-  ): Unit = {
+  def run(provisioner: Provisioner, mode: RunningMode): Unit = {
     if (!config.enabled) {
       return
     }

plugin/src/main/scala/net/moznion/sbt/spotless/task/RunnableTask.scala

@@ -21,11 +21,11 @@ import java.nio.charset.Charset
 import java.nio.file.{Files, Path, StandardOpenOption}
 
 import com.diffplug.spotless.extra.integration.DiffMessageFormatter
-import com.diffplug.spotless.{Formatter, LineEnding, PaddedCell, PaddedCellBulk}
+import com.diffplug.spotless.{Formatter, LineEnding, PaddedCell, PaddedCellBulk, Provisioner}
 import net.moznion.sbt.spotless.Target.{IsFile, IsString}
 import net.moznion.sbt.spotless.config.{FormatterConfig, SpotlessPathConfig}
 import net.moznion.sbt.spotless.exception.{ShouldTurnOnPaddedCellException, ViolatedFormatException}
-import net.moznion.sbt.spotless.{FormatterSteps, Target}
+import net.moznion.sbt.spotless.{FormatterSteps, RunningMode, Target}
 import sbt.util.Logger
 
 import _root_.scala.collection.JavaConverters._
@@ -36,6 +36,8 @@ trait RunnableTask[T <: FormatterConfig] {
 
   private[spotless] def getTarget: Seq[File]
 
+  private[sbt] def run(provisioner: Provisioner, mode: RunningMode): Unit
+
   private[spotless] def resolveTarget(target: Seq[Target], baseDir: File): Seq[File] = {
     target.flatMap {
       case IsFile(file) => Seq(file)
@@ -96,9 +98,9 @@ trait RunnableTask[T <: FormatterConfig] {
       logger: Logger,
   ): Unit = {
     if (problemFiles.isEmpty) {
-      logger.info(s"""|${getName} is in `paddedCell` mode, but it doesn't need to be.
+      logger.info(s"""|$getName is in `paddedCell` mode, but it doesn't need to be.
                       |If you remove that option, spotless will run ~2x faster.
-                      |For details see ${paddedCellDescriptionURL}""".stripMargin)
+                      |For details see $paddedCellDescriptionURL""".stripMargin)
     }
 
     val stillFailingFiles = PaddedCellBulk.check(
@@ -204,6 +206,6 @@ trait RunnableTask[T <: FormatterConfig] {
       .build()
   }
 
-  def getName: String;
-  def getClassName: String;
+  def getName: String
+  def getClassName: String
 }