From 8e709180304327fd07c741f9817bbc74adca584e Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Thu, 8 Dec 2011 16:52:53 -0800 Subject: Deleted the sbt 0.7 project. Pretty sure nobody's using this? Let's make some space for our upcoming friend the 0.11 project. --- project/build/BasicLayer.scala | 296 ----------------------------------------- 1 file changed, 296 deletions(-) delete mode 100644 project/build/BasicLayer.scala (limited to 'project/build/BasicLayer.scala') diff --git a/project/build/BasicLayer.scala b/project/build/BasicLayer.scala deleted file mode 100644 index b333131d51..0000000000 --- a/project/build/BasicLayer.scala +++ /dev/null @@ -1,296 +0,0 @@ -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) -} -- cgit v1.2.3