Accumulate Teilprojekte '' discoveredMainClasses`

Question

Wie kann ich alle discoveredMainClasses eines Projekts zusammen mit seinen abhängigen Teilprojekten in SBT akkumulieren?

Zum Beispiel habe ich ein Projekt, das

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

Mit einem root Projekt wie

sieht, dass aggregate(foo, bar), erhalte ich die folgende für discoveredMainClasses:

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

Mit einem root, dass nur dependsOn(foo, bar) ich

> show discoveredMainClasses 
[info] * 

Wie kann ich show root/discoveredMainClasses sowohl MainFoo als auch MainBar enthalten?

Für Kontext, ich habe andere Aufgaben, die von discoveredMainClasses am Ausgang hängt nämlich die makeBashScripts in native-packager

Answer 1

Die Kernidee ist es, ein Modul zu erstellen, die Sie einbeziehen möchten, und konfigurieren auf allen allen Teilmodulen hängt alles Einstellungen auf diesem Modul. Diese

führt zu einer build.sbt wie diese

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

Die (discoveredMainClasses in (client, Compile)).value greift auf die discoveredMainClasses aus dem Client-Projekt im Rahmen Compile.

Sie können Ihre Anwendungen mit

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

A running example can be found here bauen und betreiben.

prost, Muki

Answer 2

Ein alternativer Weg zu @ Antwort des Muki wäre eine ScopeFilter, die alles zu definieren, aber root und akkumulieren Hauptklassen, die Art und Weise enthält. Dies hat den Vorteil, dass man nicht überall client, wiederholen muss.

Das resultierende 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, 
    ... 
)