org.jetbrains.kotlin.gradle.tasks.SourceRoots.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of kotlin-gradle-plugin Show documentation
null
There is a newer version: 2.0.20-RC
package org.jetbrains.kotlin.gradle.tasks

import org.gradle.api.file.FileTree
import org.gradle.api.file.SourceDirectorySet
import org.gradle.api.logging.Logger
import org.jetbrains.kotlin.gradle.logging.kotlinDebug
import org.jetbrains.kotlin.gradle.utils.isJavaFile
import org.jetbrains.kotlin.gradle.utils.isKotlinFile
import org.jetbrains.kotlin.gradle.utils.isParentOf
import java.io.File
import java.util.*

internal sealed class SourceRoots(val kotlinSourceFiles: List) {
    private companion object {
        fun dumpPaths(files: Iterable): String =
            "[${files.map { it.canonicalPath }.sorted().joinToString(prefix = "\n\t", separator = ",\n\t")}]"
    }

    open fun log(taskName: String, logger: Logger) {
        logger.kotlinDebug { "$taskName source roots: ${dumpPaths(kotlinSourceFiles)}" }
    }

    class ForJvm(kotlinSourceFiles: List, val javaSourceRoots: Set) : SourceRoots(kotlinSourceFiles) {
        companion object {
            fun create(taskSource: FileTree, sourceRoots: FilteringSourceRootsContainer, sourceFilesExtensions: List): ForJvm {
                val kotlinSourceFiles = (taskSource as Iterable).filter { it.isKotlinFile(sourceFilesExtensions) }
                val javaSourceRoots = findRootsForSources(
                    sourceRoots.sourceRoots, taskSource.filter(File::isJavaFile)
                )
                return ForJvm(kotlinSourceFiles, javaSourceRoots)
            }

            private fun findRootsForSources(allSourceRoots: Iterable, sources: Iterable): Set {
                val resultRoots = HashSet()
                val sourceDirs = sources.mapTo(HashSet()) { it.parentFile }

                for (sourceDir in sourceDirs) {
                    for (sourceRoot in allSourceRoots) {
                        if (sourceRoot.isParentOf(sourceDir)) {
                            resultRoots.add(sourceRoot)
                        }
                    }
                }

                return resultRoots
            }
        }

        override fun log(taskName: String, logger: Logger) {
            super.log(taskName, logger)
            logger.kotlinDebug { "$taskName java source roots: ${dumpPaths(javaSourceRoots)}" }
        }
    }

    class KotlinOnly(kotlinSourceFiles: List) : SourceRoots(kotlinSourceFiles) {
        companion object {
            fun create(taskSource: FileTree, sourceFilesExtensions: List) =
                KotlinOnly((taskSource as Iterable).filter { it.isKotlinFile(sourceFilesExtensions) })
        }
    }
}

internal class FilteringSourceRootsContainer(roots: List = emptyList(), val filter: (File) -> Boolean = { true }) {
    private val mutableSourceRoots = roots.filterTo(mutableListOf(), filter)

    val sourceRoots: List
        get() = mutableSourceRoots

    fun clear() {
        mutableSourceRoots.clear()
    }

    fun set(source: Any?): List {
        clear()
        return add(source)
    }

    fun add(vararg sources: Any?): List {
        val filteredDirs = mutableListOf()
        for (source in sources) {
            when (source) {
                is SourceDirectorySet -> filteredDirs += source.srcDirs.filter { filter(it) }
                is File -> if (filter(source)) filteredDirs.add(source)
                is Collection<*> -> source.forEach { filteredDirs += add(it) }
                is Array<*> -> source.forEach { filteredDirs += add(it) }
            }
        }

        mutableSourceRoots += filteredDirs
        return filteredDirs
    }
}