sbt with sub-modules and multiple scala versions

Question

I'm building a scala applications with these module and dependencies :

a shared lib "common"
module "A" depends on "common" and can be built in scala 2.10 only
module "B" depends on "common" and can be built in scala 2.11+ only

I'm trying to have all the 3 modules in a single sbt build :

import sbt._
import Keys._

lazy val root = (project in file("."))
                .aggregate(common, A, B)

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

lazy val A = (project in file("A"))
             .dependsOn(common)

lazy val B = (project in file("B"))
             .dependsOn(common)

I've read things about crossScalaVersions, but whatever combination I try in root build, or in common, etc, I can't manage to make this work properly.

Any clue ? I'm using sbt 0.13.8 by the way.

sbt-doge, use it, it addresses this particular situation – pfn May 05 '16 at 15:41 — pfn, May 05 '16 at 15:41
sbt-dodge is really helpful, thanks for the pointer @pfn – Achim Nierbeck May 13 '16 at 13:39 — Achim Nierbeck, May 13 '16 at 13:39
`sbt-doge` does not address this problem at all. – Atais Jul 14 '17 at 19:02 — Atais, Jul 14 '17 at 19:02

Atais · Answer 1 · 2017-07-14T19:24:20.440

Using bare sbt this might not be possible.

An example build.sbt file representing such situation:

lazy val common = (project in file("common"))
                  .settings(crossScalaVersions := Seq("2.10.6", "2.11.8"))

lazy val A = (project in file("A"))
             .settings(scalaVersion := "2.10.6")
             .dependsOn(common)

lazy val B = (project in file("B"))
             .settings(scalaVersion := "2.11.8")
             .dependsOn(common)

This will work just fine.

Now. A compilation of any project leads to a creation of a package. Even for the root. If you follow the console, at some point it says:

Packaging /project/com.github.atais/target/scala-2.10/root_2.10-0.1.jar

So as you see sbt needs to decide on some Scala version, just to build this jar! That being said your projects A and B must have a common Scala version so they can be aggregated in a common project root.

Therefore, you can't have:

lazy val root = (project in file("."))
                .aggregate(common, A, B)

if they do not share any Scala version they could be built with.

But... sbt-cross to the rescue

You can use sbt-cross plugin to help you out.

In project/plugins.sbt, add

addSbtPlugin("com.lucidchart" % "sbt-cross" % "3.2")

And define your build.sbt in a following way:

lazy val common = (project in file("common")).cross

lazy val common_2_11 = common("2.11.8")
lazy val common_2_10 = common("2.10.6")

lazy val A = (project in file("A"))
             .settings(scalaVersion := "2.10.6")
             .dependsOn(common_2_10)

lazy val B = (project in file("B"))
             .settings(scalaVersion := "2.11.8")
             .dependsOn(common_2_11)

lazy val root = (project in file("."))
                .aggregate(common, A, B)

And then it works :-)!

score 1 · Answer 2 · answered May 02 '16 at 18:13

In my experience sbt multi-module builds are quite finicky to get to work reliably if you require any extra hoops to jump through such as this requirement.

Have you considered the simpler way to achieve this:

publish your common dependency (sbt publish-local if you only need to access it yourself)
make two projects A and B
make both A and B import common as a dependency

sbt with sub-modules and multiple scala versions

2 Answers2

Using bare sbt this might not be possible.

But... sbt-cross to the rescue

Linked