Dans une construction multi-projets SBT, comment référencer les projets d'autres dossiers ?

Question

J'essaie de mettre de l'ordre dans mon énorme construction SBT multi-projets. Actuellement, j'ai tout dans un seul gros fichier SBT, mais j'essaie de le répartir dans plusieurs répertoires.

Voici, en résumé, la structure de mes dossiers :

root
+-foo
| +-foofoo
| | +-build.sbt
| +-build.sbt
| |
| +-foobar
| | +-build.sbt
| +-build.sbt
| |
| bar
| +-barfoo
| | +-build.sbt
| +-build.sbt
| |
+-build.sbt

En root/build.sbt Je l'ai fait :

lazy val root = project.
  in(file(".")).
  settings(publishArtifact := false).
  aggregate(foo,
            bar)

lazy val foo = project in file("foo")
lazy val bar = project in file("bar")

En foo/build.sbt Je l'ai fait :

lazy val foo = project.
  in(file(".")).
  settings(publishArtifact := false).
  aggregate(foofoo,
            foobar)

lazy val foofoo = project in file("foofoo")
lazy val foobar = project in file("foobar")

En bar/build.sbt Je l'ai fait :

lazy val bar = project.
  in(file(".")).
  settings(publishArtifact := false).
  aggregate(barfoo)

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

Maintenant, je veux barfoo de dépendre de foofoo donc, naïvement, j'ai défini en barfoo/build.sbt :

lazy val barfoo = project.in(file(".")).dependsOn(foofoo)

Mais quand on exécute sbt compile il se plaint qu'il ne peut pas trouver foofoo .

Alors, comment référencer correctement ces dépendances intra-projet ?

Actuellement, le seul moyen auquel je pense est d'exécuter sbt foo/publishLocal d'abord et ensuite ajouter ceci comme libraryDependencies . Est-ce le seul moyen ou en existe-t-il un autre ?

Suivi 1

Après quelques recherches, j'ai lu que ProjectRef devrait faire l'affaire, mais cela me donne une autre erreur :

J'ai quelques dépendances communes dans un Dependencies.scala dans mon project sous-dossier. Celui-ci est retrouvé par tous les sous-projets. Cependant, lorsque je définis :

lazy val foofoo = ProjectRef(file("foo/foofoo"), "foofoo")
lazy val barfoo = project.in(file(".")).dependsOn(foofoo)

Je comprends :

C:\Somewhere\bar\barfoo\build.sbt:1: error: not found: object Dependencies
import Dependencies._
       ^

Suivi 2

J'ai réussi à le faire fonctionner mais je ne sais pas si c'est la bonne approche, alors je le laisse ici mais ne le poste pas comme réponse :

lazy val foofoo = project in file("../../foo/foofoo")
lazy val barfoo = project.in(file(".")).dependsOn(foofoo)

Answer 1

Vous avez plus ou moins répondu vous-même à cette question, mais voici néanmoins ma façon de procéder :

lazy val core = RootProject(file("../../../myCoreProject/"))
lazy val main = Project(
   id = "mySubProject", 
   base = file(".")
).dependsOn(core)

où core est le projet que je veux référencer. Il se trouve dans le répertoire build.sbt du sous-projet, qui se trouve trois répertoires plus bas dans l'arborescence des fichiers.

Ver: RootProject