Allow plug-ins to contribute multiple compilers.

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt

@@ -36,14 +36,24 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
     }
 
     fun sourceDirectories(project: Project, context: KobaltContext) : List<File> {
-        val compilers = ActorUtils.selectAffinityActors(project, context, context.pluginInfo.compilerContributors)
+        val result = hashSetOf<File>()
-        val sourceSuffixes = compilers.flatMap { it.sourceSuffixes }
+        val compilerContributors = ActorUtils.selectAffinityActors(project, context,
-        val result = sourceSuffixes.flatMap {
+                context.pluginInfo.compilerContributors)
-            sourceDirectories(project, it)
+        compilerContributors.forEach {
-        }.toHashSet()
+            it.compilersFor(project, context).forEach { compiler ->
+                val sourceSuffixes = compilerContributors.flatMap { compiler.sourceSuffixes }
+                result.addAll(sourceSuffixes.flatMap {
+                    sourceDirectories(project, it)
+                })
+            }
+
+        }
         return result.toList()
     }
 
+    /**
+     * Might be used by plug-ins.
+     */
     fun resDirectories(project: Project) : List<File> = sourceDirectories(project, "res")
 
     /**

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt

@@ -2,7 +2,18 @@ package com.beust.kobalt.api
 
 import com.beust.kobalt.TaskResult
 
-interface ICompilerContributor : IProjectAffinity {
+interface ICompiler {
+    /**
+     * The suffixes handled by this compiler (without the dot, e.g. "java" or "kt").
+     */
     val sourceSuffixes: List<String>
+
+    /**
+     * Run the compilation based on the info.
+     */
     fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult
 }
+
+interface ICompilerContributor : IProjectAffinity {
+    fun compilersFor(project: Project, context: KobaltContext): List<ICompiler>
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt

@@ -165,23 +165,26 @@ open class JvmCompilerPlugin @Inject constructor(
         }
         val results = arrayListOf<TaskResult>()
 
-        val compilers = ActorUtils.selectAffinityActors(project, context, context.pluginInfo.compilerContributors)
+        val compilerContributors = ActorUtils.selectAffinityActors(project, context,
+                context.pluginInfo.compilerContributors)
 
         var failedResult: TaskResult? = null
-        if (compilers.isEmpty()) {
+        if (compilerContributors.isEmpty()) {
             throw KobaltException("Couldn't find any compiler for project ${project.name}")
         } else {
-            compilers.forEach { compiler ->
+            compilerContributors.forEach { contributor ->
-                if (containsSourceFiles(project, compiler)) {
+                contributor.compilersFor(project, context).forEach { compiler ->
-                    val info = createCompilerActionInfo(project, context, isTest, sourceDirectories,
+                    if (containsSourceFiles(project, compiler)) {
-                            sourceSuffixes = compiler.sourceSuffixes)
+                        val info = createCompilerActionInfo(project, context, isTest, sourceDirectories,
-                    val thisResult = compiler.compile(project, context, info)
+                                sourceSuffixes = compiler.sourceSuffixes)
-                    results.add(thisResult)
+                        val thisResult = compiler.compile(project, context, info)
-                    if (!thisResult.success && failedResult == null) {
+                        results.add(thisResult)
-                        failedResult = thisResult
+                        if (!thisResult.success && failedResult == null) {
+                            failedResult = thisResult
+                        }
+                    } else {
+                        log(2, "Compiler $compiler not running on ${project.name} since no source files were found")
                     }
-                } else {
-                    log(2, "Compiler $compiler not running on ${project.name} since no source files were found")
                 }
             }
             return if (failedResult != null) failedResult!!
@@ -189,7 +192,7 @@ open class JvmCompilerPlugin @Inject constructor(
         }
     }
 
-    private fun containsSourceFiles(project: Project, compiler: ICompilerContributor): Boolean {
+    private fun containsSourceFiles(project: Project, compiler: ICompiler): Boolean {
         project.projectExtra.suffixesFound.forEach {
             if (compiler.sourceSuffixes.contains(it)) return true
         }
@@ -211,12 +214,14 @@ open class JvmCompilerPlugin @Inject constructor(
     fun taskJavadoc(project: Project): TaskResult {
         val docGenerator = ActorUtils.selectAffinityActor(project, context, context.pluginInfo.docContributors)
         if (docGenerator != null) {
-            val compilers = ActorUtils.selectAffinityActors(project, context, context.pluginInfo.compilerContributors)
+            val contributors = ActorUtils.selectAffinityActors(project, context, context.pluginInfo.compilerContributors)
             var result: TaskResult? = null
-            compilers.forEach { compiler ->
+            contributors.forEach {
-                result = docGenerator.generateDoc(project, context, createCompilerActionInfo(project, context,
+                it.compilersFor(project, context).forEach { compiler ->
-                        isTest = false, sourceDirectories = sourceDirectories,
+                    result = docGenerator.generateDoc(project, context, createCompilerActionInfo(project, context,
-                        sourceSuffixes = compiler.sourceSuffixes))
+                            isTest = false, sourceDirectories = sourceDirectories,
+                            sourceSuffixes = compiler.sourceSuffixes))
+                }
             }
             return result!!
         } else {

src/main/kotlin/com/beust/kobalt/plugin/java/JavaPlugin.kt

@@ -41,23 +41,28 @@ class JavaPlugin @Inject constructor(val javaCompiler: JavaCompiler)
     // ICompilerFlagsContributor
     override fun flagsFor(project: Project, context: KobaltContext, currentFlags: List<String>,
             suffixesBeingCompiled: List<String>) =
-                maybeCompilerArgs(sourceSuffixes, suffixesBeingCompiled,
+                maybeCompilerArgs(compiler.sourceSuffixes, suffixesBeingCompiled,
                         configurationFor(project)?.compilerArgs ?: listOf<String>())
 
     // ICompilerContributor
-    override val sourceSuffixes = listOf("java")
+    val compiler = object: ICompiler {
+        // ICompilerContributor
+        override val sourceSuffixes = listOf("java")
 
-    override fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult {
+        override fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo): TaskResult {
-        val result =
+            val result =
-            if (info.sourceFiles.size > 0) {
+                    if (info.sourceFiles.size > 0) {
-                javaCompiler.compile(project, context, info)
+                        javaCompiler.compile(project, context, info)
-            } else {
+                    } else {
-                warn("Couldn't find any source files to compile")
+                        warn("Couldn't find any source files to compile")
-                TaskResult()
+                        TaskResult()
-            }
+                    }
-        return result
+            return result
+        }
     }
 
+    override fun compilersFor(project: Project, context: KobaltContext) = arrayListOf(compiler)
+
     // ITestSourceDirectoryContributor
     override fun testSourceDirectoriesFor(project: Project, context: KobaltContext)
         = project.sourceDirectoriesTest.map { File(it) }.toList()
@@ -65,7 +70,7 @@ class JavaPlugin @Inject constructor(val javaCompiler: JavaCompiler)
     // IBuildConfigContributor
     override fun affinity(project: Project) = if (project.projectExtra.suffixesFound.contains("java")) 1 else 0
 
-    override val buildConfigSuffix = sourceSuffixes[0]
+    override val buildConfigSuffix = compiler.sourceSuffixes[0]
 
     override fun generateBuildConfig(project: Project, context: KobaltContext, packageName: String,
             variant: Variant, buildConfigs: List<BuildConfig>): String {

src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinPlugin.kt

@@ -39,7 +39,7 @@ class KotlinPlugin @Inject constructor(val executors: KobaltExecutors)
     // ICompilerFlagsContributor
     override fun flagsFor(project: Project, context: KobaltContext, currentFlags: List<String>,
             suffixesBeingCompiled: List<String>) : List<String> {
-            val result = maybeCompilerArgs(sourceSuffixes, suffixesBeingCompiled,
+            val result = maybeCompilerArgs(compiler.sourceSuffixes, suffixesBeingCompiled,
                     configurationFor(project)?.compilerArgs ?: listOf<String>())
             return result
     }
@@ -105,22 +105,26 @@ class KotlinPlugin @Inject constructor(val executors: KobaltExecutors)
 
     // ICompilerContributor
 
-    override val sourceSuffixes = listOf("kt")
+    val compiler = object: ICompiler {
+        override val sourceSuffixes = listOf("kt")
 
-    override fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult {
+        override fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo): TaskResult {
-        val result =
+            val result =
-            if (info.sourceFiles.size > 0) {
+                    if (info.sourceFiles.size > 0) {
-                compilePrivate(project, info.dependencies, info.sourceFiles, info.outputDir, info.compilerArgs)
+                        compilePrivate(project, info.dependencies, info.sourceFiles, info.outputDir, info.compilerArgs)
-            } else {
+                    } else {
-                warn("Couldn't find any source files")
+                        warn("Couldn't find any source files")
-                TaskResult()
+                        TaskResult()
-            }
+                    }
 
-        lp(project, "Compilation " + if (result.success) "succeeded" else "failed")
+            lp(project, "Compilation " + if (result.success) "succeeded" else "failed")
-        return result
+            return result
+        }
     }
 
-//    private val dokkaConfigurations = ArrayListMultimap.create<String, DokkaConfig>()
+    override fun compilersFor(project: Project, context: KobaltContext) = arrayListOf(compiler)
+
+    //    private val dokkaConfigurations = ArrayListMultimap.create<String, DokkaConfig>()
 //
 //    fun addDokkaConfiguration(project: Project, dokkaConfig: DokkaConfig) {
 //        dokkaConfigurations.put(project.name, dokkaConfig)