Scala example source code file (BasicLayer.scala)

This example Scala source code file (BasicLayer.scala) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Scala tags/keywords

compilationstep, compilationstep, list, list, nil, nil, packaging, packagingconfiguration, path, pathfinder, resourcestocopy, seq, seq, wrapperstep

The Scala BasicLayer.scala source code

import sbt._
import xsbt.ScalaInstance
import ScalaBuildProject._

/**
 * 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 ScalaBuildProject 
           with ReflectiveProject
           with AdditionalResources 
           with LayerCompilation
           with BuildInfoEnvironment 
           with ForkSBT {
  layer =>
  
  // All path values must be lazy in order to avoid initialization issues (sbt way of doing things)

  def buildInfoEnvironmentLocation: Path = outputRootPath / ("build-"+name+".properties")
  
  val forkProperty = "scala.sbt.forked"
  def isDebug  = info.logger atLevel Level.Debug
  def isForked = System.getProperty(forkProperty) != null

  // Support of triggered execution at project level
  override def watchPaths = info.projectPath / "src" ** ("*.scala" || "*.java" || AdditionalResources.basicFilter)
  override def dependencies = info.dependencies

  lazy val copyright = property[String]
  lazy val partestVersionNumber = property[Version]
  
  lazy val nextLayer: Option[BasicLayer] = None
  def packingDestination : Path = layerOutput / "pack"  
  lazy val libsDestination = packingDestination/ "lib"
  lazy val packedStarrOutput = outputRootPath / "pasta"
  lazy val requiredPluginsDirForCompilation = layerOutput / "misc" / "scala-devel" / "plugins"
  
  def compilerAdditionalJars: List[Path] = Nil
  def libraryAdditionalJars: List[Path] = Nil

  // TASKS

  /**
   * 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 _              => task(None)
  }

  def buildLayer = externalCompilation orElse writeProperties

  lazy val build = compile
  
  lazy val compile = task(buildLayer) dependsOn startLayer

  /**
   * 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: ManagedTask = task(None) dependsOn compile
  
  def cleaningList = List(
    layerOutput,
    layerEnvironment.envBackingPath,
    packingDestination
  )

  def  cleanFiles = FileUtilities.clean(cleaningList, true, log)

  // We use super.task, so cleaning is done in every case, even when locked
  lazy val clean: Task = nextLayer match {
    case Some(next)   => super.task(cleanFiles) dependsOn next.clean
    case _            => super.task(cleanFiles)    
  }
  lazy val cleanBuild = task(cleanFiles orElse buildLayer) dependsOn startLayer

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

  // CONFIGURATION OF THE COMPILATION STEPS
   
 /**
   *  Configuration of the core library compilation
   */
  lazy val libraryConfig = new CompilationStep("library", pathLayout , log) with ResourcesToCopy with PropertiesToWrite {
    def label = "["+layer.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 = "["+layer.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

    lazy val packagingConfig = {
      import java.util.jar.Manifest
      import java.io.FileInputStream
      val manifest = new Manifest(new FileInputStream(manifestPath.asFile))
      new PackagingConfiguration(libsDestination / compilerJarName, List(outputDirectory ##), manifest , compilerAdditionalJars)
    }
    lazy val starrPackagingConfig = new PackagingConfiguration(packedStarrOutput/compilerJarName, List(outputDirectory ##))
    
  }

  //// ADDTIONNAL LIBRARIES ////

  /**
   * Config of the actors library
   */
  lazy val actorsConfig = new CompilationStep ("actors", pathLayout, log){
    def label = "["+layer.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 = "["+layer.name+"] dbc library"
    def options: Seq[String] = Seq()
    def dependencies = libraryConfig :: Nil
    
    lazy val packagingConfig = new PackagingConfiguration(
      libsDestination / dbcJarName,
      List(outputDirectory ##)
    )
  }

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

    lazy val packagingConfig = new PackagingConfiguration(
      libsDestination / swingJarName,
      List(outputDirectory ##)
    )
  }

  ///// TOOLS CONFIGURATION ////////

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

    lazy val packagingConfig = new PackagingConfiguration(
      libsDestination / scalacheckJarName,
      List(outputDirectory ##)
    )
  }

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

    val decoderProperties = (srcDir ## ) / "decoder.properties"
      
    lazy val packagingConfig = new PackagingConfiguration(
      libsDestination / scalapJarName,
      List(outputDirectory ##, decoderProperties)
    )
  }

  /**
   * Configuration of the partest tool
   */
  lazy val partestConfig = new CompilationStep("partest", pathLayout, log) with ResourcesToCopy with PropertiesToWrite with Packaging {
    def label = "["+layer.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 = List(
      ("version.number", partestVersionNumber.value.toString),
      ("copyright.string", copyright.value)
    )
    
    lazy val packagingConfig = new PackagingConfiguration(libsDestination / partestJarName, List(outputDirectory ##))    
    
  }

  ///// PLUGINS CONFIGURATION ////////

  lazy val continuationPluginConfig = {
    val config = new PathConfig {
      def projectRoot: Path = pathLayout.projectRoot
      def sources: Path     = pathLayout.srcDir / "continuations" / "plugin"
      def analysis: Path    = pathLayout.analysisOutput / "continuations" / "plugin"
      def output: Path      = pathLayout.classesOutput / "continuations" / "plugin"     
    }
        
    new CompilationStep("continuation-plugin", config, log) with ResourcesToCopy with EarlyPackaging {
      def label = "["+layer.name+"] continuation plugin"
      def dependencies = libraryConfig :: compilerConfig :: Nil
      def options = Seq()

      def filesToCopy     = (sourceRoots ##) / "scalac-plugin.xml"
      def copyDestination = outputDirectory
      def jarContent      = List(outputDirectory ##)
      lazy val packagingConfig = new PackagingConfiguration(
        requiredPluginsDirForCompilation/"continuations.jar",
        List(outputDirectory ##)
      )
      lazy val earlyPackagingConfig = new PackagingConfiguration(
        pathLayout.outputDir / "misc" / "scala-devel" / "plugins" / "continuations.jar",
        List(outputDirectory ##)
      )
    }
  }

  lazy val continuationLibraryConfig = {
    val config = new PathConfig {
       def projectRoot: Path = pathLayout.projectRoot
       def sources: Path     = pathLayout.srcDir / "continuations" / "library"
       def analysis: Path    = pathLayout.analysisOutput / "continuations" / "library"
       def output: Path      = pathLayout.classesOutput / "continuations" / "library"     
     }
    
    new CompilationStep("continuation-library", config, log) {
      def label = "["+layer.name+"] continuation library"
      def dependencies = libraryConfig :: compilerConfig :: continuationPluginConfig :: Nil
      def options = Seq(
        "-Xpluginsdir",
        requiredPluginsDirForCompilation.absolutePath,
        "-Xplugin-require:continuations",
        "-P:continuations:enable"
      )
    }
  }

  // Grouping compilation steps
  def minimalCompilation = false // It must be true for locker because we do not need to compile everything
  
  def libraryWS: WrapperStep with Packaging
  def toolsWS: WrapperStep

  lazy val pluginsWS = new WrapperStep(continuationPluginConfig :: continuationLibraryConfig :: Nil) 
  lazy val allSteps  = new WrapperStep(libraryWS :: compilerConfig :: pluginsWS :: toolsWS :: Nil)
}