mirror of https://github.com/sbt/sbt.git
111 lines
4.3 KiB
Scala
111 lines
4.3 KiB
Scala
/* sbt -- Simple Build Tool
|
|
* Copyright 2010 Mark Harrah
|
|
*/
|
|
package sbt
|
|
|
|
import std._
|
|
import compile.{Discovered,Discovery}
|
|
import inc.Analysis
|
|
import TaskExtra._
|
|
import Configurations.{Compile => CompileConfig, Test => TestConfig, Runtime => RunConfig}
|
|
import ClasspathProject._
|
|
import Types._
|
|
import xsbti.api.Definition
|
|
|
|
import java.io.File
|
|
|
|
class DefaultProject(val info: ProjectInfo) extends BasicProject
|
|
{
|
|
override def name = "test"
|
|
}
|
|
abstract class BasicProject extends TestProject with MultiClasspathProject with ReflectiveClasspathProject
|
|
{
|
|
// easier to demo for now
|
|
override def organization = "org.example"
|
|
override def version = "1.0"
|
|
|
|
override def watchPaths: PathFinder = descendents("src","*")
|
|
|
|
def javacOptions: Seq[String] = Nil
|
|
def scalacOptions: Seq[String] = Nil
|
|
|
|
def outputDirectory = "target": Path
|
|
def cacheDirectory = outputDirectory / "cache"
|
|
|
|
def classesDirectory(configuration: Configuration): File =
|
|
configuration match {
|
|
case CompileConfig => outputDirectory / "classes"
|
|
case x => outputDirectory / (x.toString + "-classes")
|
|
}
|
|
|
|
// TODO: resources, jars, test classes
|
|
lazy val products: Classpath =
|
|
TaskMap { (conf: Configuration) =>
|
|
conf match {
|
|
case CompileConfig | RunConfig => analyzed(compile, compileInputs) named(name + "/analyzed") map { _ :: Nil } named(name + "/products")
|
|
case x => error("Unknown compilation configuration: " + x)
|
|
}
|
|
}
|
|
|
|
lazy val buildScalaInstance: Task[ScalaInstance] = task {
|
|
val provider = info.app.scalaProvider
|
|
ScalaInstance(provider.version, provider)
|
|
}
|
|
|
|
lazy val discover: Task[Seq[(Definition,Discovered)]] =
|
|
compile map { analysis => Discovery(Set.empty, Set.empty)(analysis.apis.internal.values.flatMap(_.definitions).toSeq) }
|
|
|
|
lazy val discoveredMainClasses: Task[Seq[String]] =
|
|
discover map { _ collect { case (definition, discovered) if(discovered.hasMain) => definition.name } }
|
|
|
|
lazy val runMainClass: Task[Option[String]] =
|
|
discoveredMainClasses map { classes => SelectMainClass(Some(SimpleReader readLine _), classes) }
|
|
|
|
lazy val pkgMainClass: Task[Option[String]] =
|
|
discoveredMainClasses map { classes => SelectMainClass(None, classes) }
|
|
|
|
lazy val runner: Task[ScalaRun] =
|
|
buildScalaInstance map { si => new Run(si) }
|
|
|
|
lazy val run = (input :^: fullClasspath(RunConfig) :^: runMainClass :^: streams :^: runner :^: KNil) map { case in :+: cp :+: main :+: s :+: r :+: HNil =>
|
|
val mainClass = main getOrElse error("No main class detected.")
|
|
val classpath = cp.map(x => Path.fromFile(x.data))
|
|
r.run(mainClass, classpath, in.splitArgs, s.log) foreach error
|
|
}
|
|
lazy val clean = task {
|
|
IO.delete(outputDirectory)
|
|
}
|
|
lazy val set = input map { in =>
|
|
val Seq(name, value) = in.splitArgs.take(2)
|
|
println(name + "=" + value)
|
|
java.lang.System.setProperty(name, value)
|
|
}
|
|
|
|
def sourceFilter: FileFilter = "*.java" | "*.scala"
|
|
|
|
def compileTask(inputs: Task[Compile.Inputs]): Task[Analysis] = inputs map Compile.apply
|
|
|
|
def compileInputsTask(configuration: Configuration, base: PathFinder, scalaInstance: Task[ScalaInstance]): Task[Compile.Inputs] =
|
|
{
|
|
val dep = dependencyClasspath(configuration)
|
|
val prod: Task[Seq[Attributed[File]]] = (configuration.extendsConfigs map products).join.map(_.flatten)
|
|
(dep, prod, scalaInstance) map { case (cp :+: prodcp :+: si :+: HNil) =>
|
|
val log = ConsoleLogger()
|
|
val compilers = Compile.compilers(si)(info.configuration, log)
|
|
val javaSrc = base / "java"
|
|
val scalaSrc = base / "scala"
|
|
val out = "target" / si.actualVersion
|
|
import Path._
|
|
val sources = descendents((javaSrc +++ scalaSrc), sourceFilter) +++ (if(configuration == CompileConfig) info.projectDirectory * (sourceFilter -- defaultExcludes) else Path.emptyPathFinder)
|
|
val classes = classesDirectory(configuration)
|
|
val classpath = (classes +: data(prodcp)) ++ data(cp)
|
|
val analysis = analysisMap(prodcp ++ cp)
|
|
val cache = cacheDirectory / "compile" / configuration.toString
|
|
Compile.inputs(classpath, sources.getFiles.toSeq, classes, scalacOptions, javacOptions, javaSrc.getFiles.toSeq, analysis, cache, 100)(compilers, log)
|
|
}
|
|
}
|
|
|
|
lazy val compileInputs: Task[Compile.Inputs] = compileInputsTask(Configurations.Compile, "src" / "main", buildScalaInstance) named(name + "/compile-inputs")
|
|
lazy val compile: Task[Analysis] = compileTask(compileInputs) named(name + "/compile")
|
|
}
|