Scala – How to manage multiple interdependent modules with SBT and IntelliJ IDEA

intellij-ideasbtsbt-ideascala

I'm developing several modules with dependencies among them, and would like to work with them all together in one IDEA project. I'm using sbt-idea to generate IDEA projects from the sbt build definitions, which works great for individual projects. In the multiple-module case, however, the things I've tried so far don't quite work:

Use sbt-idea to generate an IDEA .iml file for each module independently; then create a master IDEA project from scratch an add those modules to it. This makes the module sources all editable in the same window, but the dependencies among them are not tracked (so trying to navigate from some source within the foo project to something in bar takes me to the imported library version of bar, not the local sources).

Use sbt multi-project builds (aka subprojects), where the parent project's Build.scala contains things like:

lazy val foo = Project(id = "foo", base = file("foo"))
lazy val bar = Project(id = "bar", base = file("bar")) dependsOn(foo)

This almost works, in that sbt-idea generates a master IDEA project with the dependencies among the subprojects tracked. There are however two caveats:

It seems to be an sbt restriction that the subprojects must live in subdirectories of the master project (i.e., file("../foo") is not allowed). This is not really what I want (what if a module–such as a "utils" or "commons" package–is used in two different master projects?) but I can live with it.
One of my subprojects has its own subprojects; I'm not sure whether sbt itself deals with these nested projects correctly, but in any case they are ignored by sbt-idea. Obviously I need nested subprojects to be included recursively in the master project.

To summarize: I'd like to collect modules which may already have subprojects into one big IDEA project with tracked dependencies for convenient editing. How can I do it? Thanks!

Best Answer

The approach with multi-project build is the correct one. You can have a nested tree of subprojects of arbitrary length, but you cannot have a module belonging to multiple parent projects. This makes absolutely sense, and in Maven happens the same.

The reason is that it would be hard to have the same module into multiple projects and keep the sources synchronized. A normal workflow is the following:

You have a project which the module belongs to, where you modify the module source.
You publish the module into your local repository
In other projects where you need the module, you declare it as a libraryDependency

If you want to load a module which does not belong to the current project inside Idea, this is however feasible as you can add this as an external module to the workspace:

SBT-IDEA generates the .iml files for your project and you import them in the workspace
You can add other.iml of other projects to the workspace
If you modify external SBT modules that you have manually added to the workspace, you should republish them to get the changes visibile on the "main" project, which sees those external modules are a "libraryDependency"

IntelliJ

IntelliJ IDEA has become so much better these days. The current version (14.0.2) supports sbt projects out of the box with the Scala plugin. Just install the plugin and you should be able to open up Scala/sbt projects without any troubles.

Scala plugin under Plugins in Preferences

With the plugin, just point at a sbt project and IDEA is going to offer you a wizard to open that kind of project.

Import sbt project

IntelliJ Scala Plugin

IntelliJ plugin can be found here http://confluence.jetbrains.com/display/SCA/Scala+Plugin+for+IntelliJ+IDEA or can be installed directoly from within the IDE using Settings -> Plugins dialog. Afterwards one can just do File -> New Project -> Scala -> SBT based. IntelliJ will generate basic build.sbt, download necessary dependencies and open project.

SBT Plugin

Sbt plugin that generate an idea project based on the sbt files can be found here: https://github.com/mpeltonen/sbt-idea

SBT 12.0+ & 13.0+

Simply add addSbtPlugin("com.github.mpeltonen" % "sbt-idea" % "1.5.2") to your build.sbt; no additional resolvers are needed.

Older Versions:

SBT 0.11+

Create and add the following lines to ~/.sbt/plugins/build.sbt OR PROJECT_DIR/project/plugins.sbt

resolvers += "sbt-idea-repo" at "http://mpeltonen.github.com/maven/"

addSbtPlugin("com.github.mpeltonen" % "sbt-idea" % "1.6.0")

Use gen-idea in sbt to create IDEA project files.

By default, classifiers (i.e. sources and javadocs) of sbt and library dependencies are loaded if found and references added to IDEA project files. If you don't want to download/reference them, use command gen-idea no-classifiers no-sbt-classifiers.

SBT 0.10.1 (according to the plugin author, 0.10.0 won't work!)

Create and add the following lines to ~/.sbt/plugins/build.sbt:

resolvers += "sbt-idea-repo" at "http://mpeltonen.github.com/maven/"

libraryDependencies += "com.github.mpeltonen" %% "sbt-idea" % "0.10.0"

Use gen-idea sbt task to create IDEA project files.

SBT 0.7

To use it, simply run this from your sbt shell, it will use the plugin as an external program:

 > *sbtIdeaRepo at http://mpeltonen.github.com/maven/
 > *idea is com.github.mpeltonen sbt-idea-processor 0.4.0
 ...
 > update
 ...
 > idea
 ...

You can also add trait in your project definition, as you want:

import sbt._
class MyProject(info: ProjectInfo) extends ParentProject(info) with IdeaProject {
  lazy val mySubProject = project("my-subproject", "my-subproject", new DefaultProject(_) with IdeaProject)
   // ...
}

Scala – Getting IntelliJ IDEA understand SBT dependencies

Use the sbt-idea plugin for SBT. Then you can run "gen-idea" from the sbt command line and it will generate the metadata files used by IDEA. These files contain the locations of jars as SBT uses them so that IDEA will know where the dependencies are, just like SBT.

Best Answer

Related Solutions

Scala – How to create SBT project with IntelliJ Idea

IntelliJ

IntelliJ Scala Plugin

SBT Plugin

Older Versions:

Scala – Getting IntelliJ IDEA understand SBT dependencies

Related Topic