scala - SBT:如何在多项目构建中使一项任务依赖于另一项，而不是在根项目中运行？

Question

对于我的多项目构建，我正在尝试创建一个验证任务，该任务只会导致 scct:test 然后按顺序执行 scalastyle。我希望 scct:test 为所有子项目执行，但不是顶级项目。 (如果它针对顶级项目执行，我会从 scct 获得“等待覆盖率报告超时”，因为该项目中没有源代码和测试。)我本来想做的是创建验证作为任务依赖 scct:test 和 scalastyle。结果证明这是相当巴洛克风格的。这是我的顶级项目/目录中的 Build.scala:

object MyBuild extends Build {
  val verifyTask = TaskKey[Unit]("verify", "Compiles, runs tests via scct:test and then runs scalastyle")
  val scctTestTask = (test in ScctPlugin.Scct).scopedKey
  val scalastyleTask = PluginKeys.scalastyleTarget.scopedKey

  lazy val root = Project("rootProject",
                      file("."),
                      settings =  Defaults.defaultSettings ++
                                  ScalastylePlugin.Settings ++
                                  ScctPlugin.instrumentSettings ++
                                  ScctPlugin.mergeReportSettings ++
                                  Seq(
                                    verifyTask in Global := {},
                                    verifyTask <<= verifyTask.dependsOn(scctTestTask, scalastyleTask)
                                  )
              ) aggregate(lift_webapp, selenium_tests)

  lazy val subproject_1 = Project(id = "subproject_1", base = file("subproject_1"))

  lazy val subproject_2 = Project(id = "subproject_2", base = file("subproject_2"))
}

但是，verify 任务似乎只存在于根项目中；当我运行它时，我没有看到子项目中正在运行相同的任务。这与我想要的完全相反；我想发出 sbt verify并让 scct:test 和 scalastyle 在每个子项目中运行，但不在顶级项目中运行。我该怎么做呢？

Answer 1

方案一:在子项目中定义verifyTask

首先要注意的是，如果您希望某些任务( verify 、 test 等)在某些项目中运行，则需要将它们定义为子项目的范围。所以在你的情况下，最直接的做法是定义 verifyTask在 subproject_1和 subproject_2 .

lazy val scalaTest = "org.scalatest" %% "scalatest" % "3.0.4"

lazy val verify = taskKey[Unit]("verify")
def verifySettings = Seq(
  skip in verify := false,
  verify := (Def.taskDyn {
    val sk = (skip in verify).value
    if (sk) Def.task { println("skipping verify...") }
    else (test in Test)
  }).value
)

lazy val root = (project in file("."))
  .aggregate(sub1, sub2)
  .settings(
    verifySettings,
    scalaVersion in ThisBuild := "2.12.4",
    skip in verify := true
  )

lazy val sub1 = (project in file("sub1"))
  .settings(
    verifySettings,
    libraryDependencies += scalaTest % Test
  )

lazy val sub2 = (project in file("sub2"))
  .settings(
    verifySettings,
    libraryDependencies += scalaTest % Test
  )

解决方案 2:ScopeFilter

最近有一个 Reddit thread提到了这个问题，所以我会在那里发布我所做的事情。
如果你想在一些子项目上手动聚合，还有一种叫做 ScopeFilter 的技术。 .

请注意，我在这里使用的是 sbt 1.x，但它应该可以与 sbt 0.13 一起使用一些小改动。

lazy val packageAll = taskKey[Unit]("package all the projects")
lazy val myTask = inputKey[Unit]("foo")

lazy val root = (project in file("."))
  .aggregate(sub1, sub2)
  .settings(
    scalaVersion in ThisBuild := "2.12.4",
    packageAll := {
      (packageBin in Compile).all(nonRootsFilter).value
      ()
    },
    myTask := {
      packageAll.value
    }
  )

lazy val sub1 = (project in file("sub1"))

lazy val sub2 = (project in file("sub2"))

def nonRootsFilter = {
  import sbt.internal.inc.ReflectUtilities
  def nonRoots: List[ProjectReference] =
    allProjects filter {
      case LocalProject(p) => p != "root"
      case _               => false
    }
  def allProjects: List[ProjectReference] =
    ReflectUtilities.allVals[Project](this).values.toList map { p =>
      p: ProjectReference
    }
  ScopeFilter(inProjects(nonRoots: _*), inAnyConfiguration)
}

在上面， myTask取决于 packageAll , 聚合 (packageBin in Compile)对于所有非根子项目。

sbt:root> myTask
[info] Packaging /Users/xxx/packageall/sub1/target/scala-2.12/sub1_2.12-0.1.0-SNAPSHOT.jar ...
[info] Done packaging.
[info] Packaging /Users/xxx/packageall/sub2/target/scala-2.12/sub2_2.12-0.1.0-SNAPSHOT.jar ...
[info] Done packaging.
[success] Total time: 0 s, completed Feb 2, 2018 7:23:23 PM