1 files changed, 86 insertions, 0 deletions
diff --git a/project/build/Compilation.scala b/project/build/Compilation.scala
new file mode 100644
index 0000000000..42e3c55902
--- /dev/null
+++ b/project/build/Compilation.scala
@@ -0,0 +1,86 @@
+import sbt._
+import xsbt.{AnalyzingCompiler,ScalaInstance}
+
+/**
+ * This trait define the compilation task. It is possible to configure what it actually compiles by
+ * overriding the compilationSteps methods (useful because locker does not compile everything)
+ * @author Grégory Moix
+ */
+trait Compilation{
+  self : BasicLayer =>
+
+
+  def lastUsedCompilerVersion = layerEnvironment.lastCompilerVersion
+
+  def cleanCompilation:Option[String]= {
+    log.info("Cleaning the products of the compilation.")
+    FileUtilities.clean(layerOutput::Nil,true,log)
+  }
+
+  /**
+   * Execute the different compilation parts one after the others.
+   */
+  def compile:Option[String]={
+
+    instanceScope[Option[String]]{  scala =>
+      lazy val analyzing = new AnalyzingCompiler(scala,componentManager,xsbt.ClasspathOptions.manual,log)
+
+      def compilerVersionHasChanged:Boolean={
+        val lastVersion = lastUsedCompilerVersion.value
+        !(lastVersion.compareTo(scala.actualVersion) == 0)
+
+      }
+
+      def checkAndClean:Option[String]={
+        if (compilerVersionHasChanged){
+          log.info("The compiler version used to build this layer has changed since last time.")
+          lastUsedCompilerVersion.update(scala.actualVersion)
+          layerEnvironment.saveEnvironment
+          cleanCompilation
+        }else{
+          log.debug("The compiler version is unchanged. No need for cleaning.")
+          None
+        }
+      }
+
+      def compile0(steps:List[Step]):Option[String]= steps match{
+        case x::xs => x match{
+          case c:CompilationStep => {
+            val conditional = new CompileConditional(c, analyzing)
+            log.info("")
+            conditional.run orElse compile0(xs)
+          }
+          case _ => compile0(xs)
+        }
+        case Nil => None
+      }
+
+
+      checkAndClean orElse compile0(allSteps.topologicalSort)
+    }
+  }
+
+  /**
+   * Run the actual compilation. Should not be called directly because it is executed on the same jvm and that
+   * it could lead to memory issues. It is used only when launching a new sbt process to do the compilation.
+   */
+  lazy val compilation = task{compile}
+
+  /**
+   * Runs the compilation in another process in order to circumvent memory issues that
+   * arises when compiling every layer on the same jvm.
+   */
+  lazy val externalCompilation:ManagedTask=task{
+    val runner = new ExternalTaskRunner(projectRoot,this.name,compilation.name, log)
+    runner.runTask
+  }.dependsOn(startLayer)
+
+  /**
+   * This method permits to specify what are the different steps of the compilation process,
+   * meaning that you can customize exactly what is compiled by overriding it. It is overriden by
+   * the locker layer that doesn't compile actors, sbc, scalap, partest
+   */
+  def compilationSteps:List[CompileConfiguration] =
+    libraryConfig::actorsConfig::dbcConfig::swingConfig::compilerConfig::scalapConfig::partestConfig::Nil
+
+}