累积子项目的`discoveredMainClasses`

Question

如何在 SBT 中累积一个项目的所有 discoveredMainClasses 及其相关子项目？

例如，我有一个项目看起来像

├── bar
│   └── src
│       └── main
│           └── scala
│               └── BarMain.scala
├── build.sbt
├── foo
│   └── src
│       └── main
│           └── scala
│               └── FooMain.scala
├── project
│   └── build.properties
└── root

对于 aggregate(foo, bar) 的一个 root 项目，我得到 discoveredMainClasses 的以下结果：

[info] foo/compile:discoveredMainClasses
[info]  List(MainFoo)
[info] bar/compile:discoveredMainClasses
[info]  List(MainBar)
[info] root/compile:discoveredMainClasses
[info]  List()

有一个 root 只有 dependsOn(foo, bar) 我得到

> show discoveredMainClasses
[info] *

如何让 show root/discoveredMainClasses 同时包含 MainFoo 和 MainBar？

对于上下文，我还有其他任务取决于 discoveredMainClasses 的输出，即 native-packager

中的 makeBashScripts

Answer 1

核心思想是创建一个模块，该模块依赖于您要包含的所有子模块，并在该模块上配置所有设置。

这导致 build.sbt 像这样

lazy val root = project.in(file("."))
  // package the root module, but not the sub modules
  .enablePlugins(JavaAppPackaging)
  .settings(
    name := "application",
    // add the discoveredMainClasses to this project
    discoveredMainClasses in Compile ++= (discoveredMainClasses in (client, Compile)).value,
    discoveredMainClasses in Compile ++= (discoveredMainClasses in (server, Compile)).value
  )
  // include these modules in the resulting package
  .dependsOn(client, server)

lazy val client = project.in(file("client"))
  .settings(
    name := "client"
  )

lazy val server = project.in(file("server"))
  .settings(
    name := "server"
  )

(discoveredMainClasses in (client, Compile)).value 从编译范围内的客户端项目访问发现的 MainClasses。

您可以使用

构建和运行您的应用程序

$ sbt universal:stage
$ ./target/universal/stage/bin/client-app
$ ./target/universal/stage/bin/server-app

一个running example can be found here.

干杯，向

Answer 2

@Muki 的答案的另一种方法是定义一个 ScopeFilter，其中包括 root 以外的所有内容，并以这种方式累积 main 类。这样做的好处是不必到处重复client、server。

结果build.sbt：

lazy val allCompileButRootFilter = 
  ScopeFilter(inAggregates(ThisProject, includeRoot = false), inConfigurations(Compile))

lazy val root = project.in(file("."))
  .aggregate(client, server)
  .enablePlugins(JavaAppPackaging)
  .settings(
    discoveredMainClasses in Compile ++= 
      discoveredMainClasses.all(allCompileButRootFilter).value.flatten,
    ...
  )

累积子项目的`discoveredMainClasses`

Accumulate subprojects' `discoveredMainClasses`

scala

sbt

sbt-native-packager