Accumuler des sous-projets '`discoveredMainClasses`

Question

Comment puis-je accumuler tous les discoveredMainClasses d'un projet, ainsi que ses sous-projets dépendants dans SBT?

Par exemple, j'ai un projet qui ressemble à

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

Avec un projet root qui aggregate(foo, bar), je reçois le texte suivant pour discoveredMainClasses:

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

Avec un root qui ne dependsOn(foo, bar) je reçois

> show discoveredMainClasses 
[info] * 

Comment puis-je avoir show root/discoveredMainClasses contenir à la fois MainFoo et MainBar?

Pour le contexte, j'ai d'autres tâches qui dépendent de la sortie de discoveredMainClasses à savoir la makeBashScripts dans native-packager

Answer 1

L'idée de base est de créer un module qui dépend de tous les sous-modules que vous souhaitez inclure et configurer tous paramètres sur ce module.

Il en résulte un build.sbt comme celui-ci

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" 
) 

Le (discoveredMainClasses in (client, Compile)).value accède aux discoveredMainClasses du projet client dans le cadre Compile.

Vous pouvez créer et exécuter vos applications avec

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

A running example can be found here.

acclamations, muki

Answer 2

Une autre façon de @ la réponse de Muki serait de définir un ScopeFilter qui comprend tout, mais root et accumuler des classes principales de cette façon. Ceci a l'avantage de ne pas devoir répéter client, server partout.

Le résultat 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, 
    ... 
)