How do I create an sbt task to generate code, then include these generated managed sources in my root project?

Question

I would like to have a sbt task that I can run to generate some code. I don't want to generate this with each run, just manually run this task once in awhile. I created a skeleton project to explain (https://github.com/jinyk/sbtmanagedsrc).

build.sbt:

lazy val root = (project in file("."))
    .settings(scalaVersion := "2.11.8")
    .settings(gensomecode := genSomeCodeTask.value)
    /////////////////////////////////////////////////////////////
    // fugly way to get managed sources compiled along with main
    .settings(unmanagedSourceDirectories in Compile += baseDirectory.value / "target/scala-2.11/src_managed/")
    /////////////////////////////////////////////////////////////

lazy val gensomecode = taskKey[Seq[File]]("gen-code")
lazy val genSomeCodeTask = Def.task {
  val file = (sourceManaged in Compile).value / "SomeGenCode.scala"
  println("file: " + file)
  IO.write(file, """object SomeGenCode {
                   |  def doSomething() {
                   |    println("Hi!")
                   |  }
                   |}""".stripMargin)
  Seq(file)
}

So with the build.sbt above I can run sbt gensomecode which creates target/scala-2.11/src_managed/main/SomeGenCode.scala the default place that sbt puts "managed sources."

I would like to make this SomeGenCode available to the root project.

src/main/scala/Main.scala:

object Main extends App {
  SomeGenCode.doSomething()
}

The only thing I can figure out to do is to include the default sourceManaged directory in the root project's unmanagedSourceDirectories (see build.sbt:line 4 aka the line below the fugly way... comment). This is ugly as hell and doesn't seem like it's how managed sources are supposed to be handled.

I'm probably not understanding something basic about sbt's managed sources concept or how to handle the situation of creating an sbt task to generate sources.

What am I missing?

Answer 1

There are three options that I am familiar with:

1. Generate into the unmanaged source directories.

2. Generate on every run, by adding sourceGenerators in Compile <+= gensomecode

3. Similar to (2), but use caching so it doesn't generate the file on every compile. Full example below.

In this example, the cache is based on the content of build.sbt, so whenever that file is changed it will regenerate the file.

lazy val root = (project in file("."))
    .settings(scalaVersion := "2.11.8")
    .settings(gensomecode <<= genSomeCodeTask)

sourceGenerators in Compile <+= genSomeCodeTask

lazy val gensomecode = taskKey[Seq[File]]("gen-code")

def generateFile(sourceManaged: java.io.File) = {
  val file = sourceManaged / "main" / "SomeGenCode.scala"
  println("file: " + file)
  IO.write(file, """object SomeGenCode {
                   |  def doSomething() {
                   |    println("Hi!")
                   |  }
                   |}""".stripMargin)
  Set(file)
}

def genSomeCodeTask = (sourceManaged in Compile, streams).map {
  (sourceManaged, streams) =>

  val cachedCompile = FileFunction.cached(
      streams.cacheDirectory / "mything", 
      inStyle = FilesInfo.lastModified,
      outStyle = FilesInfo.exists) { 
        (in: Set[java.io.File]) =>
          generateFile(sourceManaged)
      }
  cachedCompile(Set(file("build.sbt"))).toSeq
}

Answer 2

I hope I wasn't too late for the answer, but let's look at this section about Unmanaged vs Managed files

Classpaths, sources, and resources are separated into two main categories: unmanaged and managed. Unmanaged files are manually created files that are outside of the control of the build. They are the inputs to the build. Managed files are under the control of the build. These include generated sources and resources as well as resolved and retrieved dependencies and compiled classes.

It seems that the key difference between "Unmanaged vs Managed" is "Manually vs Automatically". Now, if we look at documentation for "generating files". We will notice immediately that it means "generating files automatically", since generating files will happen at sbt compile.

Compile / sourceGenerators += <task of type Seq[File]>.taskValue

It makes sense. Since anything that happened during sbt compile should be removed during sbt clean.

Now, from your code below, It seems that you were trying to generate an unmanaged source file (you were not using sourceGenerators, didn't you?), to the managed source file directory. The most obvious problem with this is, your source file will be removed every time you call sbt clean, so you have to run this task again to get this file back (worse, you have to run the task manually, opposed to having the sbt compile do it for you.), thus defeating your purpose of doing it manually once in a while.

val file = (sourceManaged in Compile).value / "SomeGenCode.scala"

To fix this, you have to manually generate files to unmanaged source, which is basically your source code directory (it depends -- mine is "/app"). Yet, you have to annotate it somehow that these files are generated by some means. My solution is something like:

val file = (scalaSource in Compile).value / "generated" / "SomeGenCode.scala"

Hope this help!