path: root/project/build/BasicLayer.scala

import sbt._
import xsbt.{ScalaInstance}
import BasicLayer._
import scala.collection.immutable.{EmptyMap}

/**
 * Basic tasks and configuration shared by all layers. This class regroups the configuration and behaviour
 * shared by all layers.
 * @author Grégory Moix
 */
abstract class BasicLayer(val info:ProjectInfo,val versionNumber:String, previousLayer:Option[BasicLayer]) extends Project with ReflectiveProject
        with AdditionalResources with Compilation{
  override def dependencies = info.dependencies
  lazy val projectRoot = info.projectPath

  lazy val copyright = property[String]
  lazy val partestVersionNumber = property[Version]


  /**
   * Before compiling the layer, we need to check that the previous layer
   * was created correctly and compile it if necessary
   */
  lazy val startLayer = previousLayer match {
    case Some(previous) => task{
      None
    }.dependsOn(previous.finishLayer)
    case None => task{None}
  }

  lazy val build= task{
    None
  }.dependsOn(externalCompilation,copyAdditionalFiles,writeProperties)

  /**
   * Finish the compilation and ressources copy and generation
   * It does nothing in itself. As sbt doesn't support conditional dependencies,
   * it permit locker to override it in order to lock the layer when the compilation
   * is finished.
   */
  lazy val finishLayer = task{None}.dependsOn(build)

  def instanceScope[A](action: ScalaInstance => A):A={
    val instance = ScalaInstance(instantiationLibraryJar.asFile, instantiationCompilerJar.asFile, info.launcher, msilJar.asFile, fjbgJar.asFile)
    log.debug("Compiler will be instantiated by :" +instance.compilerJar +" and :" +instance.libraryJar )
    action(instance)
  }

  // All path values must be lazy in order to avoid initialization issues (sbt way of doing things)
  lazy val layerOutput = outputRootPath / name
  lazy val pathLayout = new PathLayout(projectRoot, layerOutput)
  lazy val manifestPath = projectRoot/"META-INF"/"MANIFEST.MF"

  // Utility methods (for quick access)
  def libraryOutput = libraryConfig.outputDirectory
  def actorsOutput = actorsConfig.outputDirectory
  def dbcOutput = dbcConfig.outputDirectory
  def swingOutput = swingConfig.outputDirectory
  def scalapOutput = scalapConfig.outputDirectory
  def librarySrcDir = libraryConfig.srcDir
  def compilerOutput = compilerConfig.outputDirectory
  def compilerSrcDir = compilerConfig.srcDir
  def actorsSrcDir = actorsConfig.srcDir
  def swingSrcDir = swingConfig.srcDir
  def outputLibraryJar = libraryWS.jarDestination
  def outputCompilerJar = compilerConfig.jarDestination
  def outputPartestJar = partestConfig.jarDestination
  def outputScalapJar = scalapConfig.jarDestination

  // CONFIGURATION OF THE COMPILTATION STEPS

 /**
   *  Configuration of the core library compilation
   */
  lazy val libraryConfig = new CompilationStep("library", pathLayout ,log) with ResourcesToCopy with PropertiesToWrite{
    def label = "["+name+"] library"
    def options: Seq[String] = Seq("-sourcepath", pathConfig.sources.absolutePath.toString)
    def dependencies = Nil
    override def classpath = super.classpath +++ forkJoinJar

    def copyDestination = outputDirectory
    def filesToCopy = getResources(srcDir)

    def propertyDestination = outputDirectory / "library.properties"
    def propertyList = ("version.number",versionNumber)::("copyright.string",copyright.value)::Nil
  }

  /**
   * Configuration of the compiler
   */
  lazy val compilerConfig = new CompilationStep("compiler", pathLayout, log) with ResourcesToCopy with PropertiesToWrite with Packaging{
    def label = "["+name+"] compiler"
    private def bootClassPath : String = {
      System.getProperty("sun.boot.class.path")
    }
    override def classpath: PathFinder = super.classpath +++ fjbgJar +++ msilJar +++ jlineJar +++ antJar +++ forkJoinJar
    def options  = Seq("-bootclasspath",bootClassPath)
    def dependencies = if (minimalCompilation) libraryConfig::Nil else libraryConfig::actorsConfig::dbcConfig::swingConfig::Nil

    def copyDestination = outputDirectory
    def filesToCopy = getResources(srcDir)

    def propertyDestination = outputDirectory / "compiler.properties"
    def propertyList = ("version.number",versionNumber)::("copyright.string",copyright.value)::Nil

    def packagingDestination:Path = packingDestination
    def jarName:String = compilerJarName
    override def jarsToInclude = compilerAdditionalJars
    override def manifest = {
      import java.util.jar.Manifest
      import java.io.FileInputStream
      new Manifest(new FileInputStream(manifestPath.asFile))
    }
    override def jarContent = List(outputDirectory ##)

  }

  /**
   * Config of the actors library
   */
  lazy val actorsConfig = new CompilationStep ("actors", pathLayout,log){
    def label = "["+name+"] actors library"
    override def classpath: PathFinder = super.classpath +++ forkJoinJar
    def options: Seq[String] = Seq()
    def dependencies = libraryConfig::Nil
  }

  /**
   * Config of the dbc library
   */
  lazy val dbcConfig = new CompilationStep("dbc", pathLayout, log) with Packaging{
    def label = "["+name+"] dbc library"
    def options: Seq[String] = Seq()
    def dependencies = libraryConfig::Nil

    def packagingDestination=packingDestination
    def jarName = dbcJarName
    def jarContent = List(outputDirectory ##)

  }

  /**
   * Config of the swing library
   */
  lazy val swingConfig = new CompilationStep("swing", pathLayout, log) with Packaging{
    def label = "["+name+"] swing library"
    def options: Seq[String] = Seq()
    def dependencies = libraryConfig::actorsConfig::Nil

    def packagingDestination=packingDestination
    def jarName = swingJarName
    def jarContent = List(outputDirectory ##)

  }


  /**
   *  Configuration of scalap tool
   */
  lazy val scalapConfig  = new CompilationStep("scalap", pathLayout,log) with Packaging{
    def label = "["+name+"] scalap"
    def options: Seq[String] = Seq()
    def dependencies = libraryConfig::compilerConfig::Nil

    def packagingDestination=packingDestination
    def jarName = scalapJarName
    def jarContent = {
      val decoderProperties = (srcDir ## )/ "decoder.properties"

      List(outputDirectory ##, decoderProperties)
   }
  }

  /**
   * Configuration of the partest tool
   */
  lazy val partestConfig = new CompilationStep("partest", pathLayout,log) with ResourcesToCopy with PropertiesToWrite with Packaging{
    def label = "["+name+"] partest"
    override def classpath: PathFinder = super.classpath +++ antJar +++ forkJoinJar
    def options: Seq[String] = Seq()
    def dependencies = libraryConfig::compilerConfig::scalapConfig::actorsConfig::Nil

    def copyDestination = outputDirectory
    def filesToCopy = getResources(srcDir)

    def propertyDestination = outputDirectory / "partest.properties"
    def propertyList = ("version.number",partestVersionNumber.value.toString)::("copyright.string",copyright.value)::Nil

    def packagingDestination=packingDestination
    def jarName = partestJarName
    def jarContent = List(outputDirectory ##)
  }

  // Grouping compilation steps
  def minimalCompilation = false // It must be true for locker because we do not nedd to compile everything

  def libraryWS:WrapperStep with Packaging
  def toolsWS:WrapperStep


  lazy val allSteps = new WrapperStep(libraryWS::compilerConfig::toolsWS::Nil)





  //Needed Libraries
  //TODO Check if not possible to manage some of them with the sbt dependency management (ivy)
  lazy val lib = projectRoot / "lib"
  lazy val forkJoinJar = lib / forkJoinJarName
  lazy val jlineJar = lib / jlineJarName
  lazy val antJar = lib / "ant" / "ant.jar"
  lazy val fjbgJar = lib / fjbgJarName
  lazy val msilJar = lib /  msilJarName




  //Paths location that must be defined layer by layer
  /*
   * We must define which are the libraries used to instantiate the compiler
   * that will be used to compile this layer.
   */
  def instantiationCompilerJar:Path
  def instantiationLibraryJar:Path
  def packingDestination :Path = layerOutput / "pack"
  def compilerAdditionalJars: List[Path] = Nil
  def libraryAdditionalJars: List[Path] = Nil


  /**
   * Environment for storing properties that
   * 1) need to be saved across sbt session
   * 2) Are local to a layer
   * Used to save the last version of the compiler used to build the layer (for discarding it's product if necessary)
   */
  lazy val layerEnvironment = new BasicEnvironment {
    // use the project's Logger for any properties-related logging
    def log = BasicLayer.this.log

    // the properties file will be read from/stored to project/extra.properties
    def envBackingPath = outputRootPath / ("build-"+name+".properties")

    // define some properties that will go in project/extra.properties
    lazy val lastCompilerVersion:Property[String] = propertyOptional[String]("")
  }
}

object BasicLayer{
  // Some path definitions related strings
  val compilerJarName = "scala-compiler.jar"
  val libraryJarName = "scala-library.jar"
  val scalapJarName = "scalap.jar"
  val dbcJarName = "scala-dbc.jar"
  val swingJarName = "scala-swing.jar"
  val partestJarName = "scala-partest.jar"
  val fjbgJarName = "fjbg.jar"
  val msilJarName = "msil.jar"
  val jlineJarName = "jline.jar"
  val forkJoinJarName = "forkjoin.jar"

  implicit def stringToGlob(s:String):NameFilter=GlobFilter(s)



}