Simplify Dokka Gradle Plugin

32 files changed, 1065 insertions, 1016 deletions

diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index f8d5c55c..df763596 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -17,11 +17,11 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
 
     val json: String? by parser.argument(ArgType.String, description = "Json file name").optional()
 
-    override val outputDir by parser.option(ArgType.String, description = "Output directory path")
+    override val outputDir by parser.option(ArgTypeFile, description = "Output directory path")
         .default(DokkaDefaults.outputDir)
 
     override val cacheRoot by parser.option(
-        ArgType.String,
+        ArgTypeFile,
         description = "Path to cache folder, or 'default' to use ~/.cache/dokka, if not provided caching is disabled"
     )
 
@@ -132,12 +132,12 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
     ).default(DokkaDefaults.sourceSetDisplayName)
 
     val classpath by parser.option(
-        ArgType.String,
+        ArgTypeFile,
         description = "Classpath for symbol resolution (allows many paths separated by the semicolon `;`)"
     ).delimiter(";")
 
     val sourceRoots by parser.option(
-        ArgType.String,
+        ArgTypeFile,
         description = "Source file or directory (allows many paths separated by the semicolon `;`)",
         fullName = "src"
     ).delimiter(";")
@@ -148,12 +148,12 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
     ).delimiter(";")
 
     val samples by parser.option(
-        ArgType.String,
+        ArgTypeFile,
         description = "Source root for samples (allows many paths separated by the semicolon `;`)"
     ).delimiter(";")
 
     val includes by parser.option(
-        ArgType.String,
+        ArgTypeFile,
         description = "Markdown files to load (allows many paths separated by the semicolon `;`)"
     ).delimiter(";")
 
@@ -196,7 +196,7 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
         .default(DokkaDefaults.noJdkLink)
 
     val suppressedFiles by parser.option(
-        ArgType.String,
+        ArgTypeFile,
         description = "Paths to files to be suppressed (allows many paths separated by the semicolon `;`)"
     ).delimiter(";")
 
@@ -228,12 +228,12 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
         override val displayName = displayName
         override val sourceSetID = DokkaSourceSetID(moduleName, sourceSetName)
         override val classpath = classpath
-        override val sourceRoots = sourceRoots.map { SourceRootImpl(it.toAbsolutePath()) }
+        override val sourceRoots = sourceRoots.map { SourceRootImpl(it) }
         override val dependentSourceSets: Set<DokkaSourceSetID> = dependentSourceSets
             .map { dependentSourceSetName -> dependentSourceSetName.split('/').let { DokkaSourceSetID(it[0], it[1]) } }
             .toSet()
-        override val samples = samples.map { it.toAbsolutePath() }
-        override val includes = includes.map { it.toAbsolutePath() }
+        override val samples = samples
+        override val includes = includes
         override val includeNonPublic = includeNonPublic
         override val includeRootPackage = includeRootPackage
         override val reportUndocumented = reportUndocumented
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTask.kt
new file mode 100644
index 00000000..bf8308bf
--- /dev/null
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTask.kt
@@ -0,0 +1,73 @@
+package org.jetbrains.dokka.gradle
+
+import org.gradle.api.Project
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.Nested
+import org.jetbrains.dokka.DokkaBootstrap
+import org.jetbrains.dokka.DokkaBootstrapImpl
+import kotlin.reflect.KClass
+
+// TODO NOW: Test UP-TO-DATE behaviour
+abstract class AbstractDokkaParentTask(
+    bootstrapClass: KClass<out DokkaBootstrap> = DokkaBootstrapImpl::class
+) : AbstractDokkaTask(bootstrapClass) {
+
+    @Input
+    open var dokkaTaskNames: Set<String> = setOf()
+
+    @Input
+    var subprojectPaths: Set<String> = project.subprojects.map { project -> project.path }.toSet()
+
+    @get:Internal
+    val subprojects: List<Project>
+        get() = subprojectPaths.map { path -> project.project(path) }.distinct()
+
+    @get:Nested
+    internal val dokkaTasks: List<AbstractDokkaTask>
+        get() = dokkaTaskNames.flatMap { dokkaTaskName -> findSubprojectDokkaTasks(dokkaTaskName) }
+
+
+    /**
+     * Will remove a single project from participating in this parent task.
+     * Note: This will not remove the [project]s subprojects.
+     *
+     * @see removeAllProjects
+     */
+    fun removeSubproject(project: Project) {
+        subprojectPaths = subprojectPaths - project.path
+    }
+
+    /**
+     * Will remove the [project] and all its subprojects from participating in this parent task.
+     * @see removeSubproject
+     */
+    fun removeAllProjects(project: Project) {
+        project.allprojects.forEach(::removeSubproject)
+    }
+
+    /**
+     * Includes the [project] to participate in this parent task.
+     * Note: This will not include any of the [project]s subprojects.
+     * @see addAllProjects
+     */
+    fun addSubproject(project: Project) {
+        subprojectPaths = (subprojectPaths + project.path)
+    }
+
+    /**
+     * Includes the [project] and all its subprojects to participate in this parent task.
+     * @see addSubproject
+     */
+    fun addAllProjects(project: Project) {
+        project.allprojects.forEach(::addSubproject)
+    }
+
+    protected fun findSubprojectDokkaTasks(dokkaTaskNames: Set<String>): List<AbstractDokkaTask> {
+        return dokkaTaskNames.flatMap { dokkaTaskName -> findSubprojectDokkaTasks(dokkaTaskName) }
+    }
+
+    private fun findSubprojectDokkaTasks(dokkaTaskName: String): List<AbstractDokkaTask> {
+        return subprojects.mapNotNull { subproject -> subproject.tasks.findByName(dokkaTaskName) as? DokkaTask }
+    }
+}
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaTask.kt
index 1269b305..6413d788 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaTask.kt
@@ -1,21 +1,33 @@
 package org.jetbrains.dokka.gradle
 
 import org.gradle.api.DefaultTask
-import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
-import org.gradle.api.attributes.Usage
-import org.gradle.api.tasks.Classpath
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.Internal
-import org.gradle.api.tasks.TaskAction
-import org.gradle.kotlin.dsl.dependencies
+import org.gradle.api.plugins.JavaBasePlugin
+import org.gradle.api.tasks.*
 import org.jetbrains.dokka.DokkaBootstrap
+import org.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.plugability.Configurable
+import org.jetbrains.dokka.toJsonString
+import java.io.File
+import java.util.function.BiConsumer
+import kotlin.reflect.KClass
 
+abstract class AbstractDokkaTask(
+    private val bootstrapClass: KClass<out DokkaBootstrap> = DokkaBootstrap::class
+) : DefaultTask(), Configurable {
+
+    @OutputDirectory
+    var outputDirectory: File = defaultDokkaOutputDirectory()
+
+    @Optional
+    @InputDirectory
+    var cacheRoot: File? = null
+
+    @Input
+    var failOnWarning: Boolean = false
 
-abstract class AbstractDokkaTask : DefaultTask(), Configurable {
     @Input
-    var outputDirectory: String = defaultDokkaOutputDirectory().absolutePath
+    var offlineMode: Boolean = false
 
     @Input
     override val pluginsConfiguration: MutableMap<String, String> = mutableMapOf()
@@ -27,19 +39,26 @@ abstract class AbstractDokkaTask : DefaultTask(), Configurable {
     val runtime: Configuration = project.maybeCreateDokkaRuntimeConfiguration(name)
 
     @TaskAction
-    protected fun run() {
-        val kotlinColorsEnabledBefore = System.getProperty(DokkaTask.COLORS_ENABLED_PROPERTY) ?: "false"
-        System.setProperty(DokkaTask.COLORS_ENABLED_PROPERTY, "false")
-        try {
+    protected open fun generateDocumentation() {
+        DokkaBootstrap(runtime, bootstrapClass).apply {
+            configure(buildDokkaConfiguration().toJsonString(), createProxyLogger())
             generate()
-        } finally {
-            System.setProperty(DokkaTask.COLORS_ENABLED_PROPERTY, kotlinColorsEnabledBefore)
         }
     }
 
-    protected abstract fun generate()
+    internal abstract fun buildDokkaConfiguration(): DokkaConfigurationImpl
+
+    private fun createProxyLogger(): BiConsumer<String, String> = BiConsumer { level, message ->
+        when (level) {
+            "debug" -> logger.debug(message)
+            "info" -> logger.info(message)
+            "progress" -> logger.lifecycle(message)
+            "warn" -> logger.warn(message)
+            "error" -> logger.error(message)
+        }
+    }
 
-    protected fun DokkaBootstrap(bootstrapClassFQName: String): DokkaBootstrap {
-        return DokkaBootstrap(runtime, bootstrapClassFQName)
+    init {
+        group = JavaBasePlugin.DOCUMENTATION_GROUP
     }
 }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
deleted file mode 100644
index 6217703f..00000000
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
+++ /dev/null
@@ -1,185 +0,0 @@
-package org.jetbrains.dokka.gradle
-
-import org.gradle.api.Project
-import org.gradle.api.Task
-import org.gradle.api.UnknownDomainObjectException
-import org.gradle.api.artifacts.ResolveException
-import org.gradle.api.file.FileCollection
-import org.gradle.api.plugins.JavaPluginConvention
-import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.compile.AbstractCompile
-import org.jetbrains.dokka.ReflectDsl
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinSingleTargetExtension
-import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeCompilation
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import java.io.File
-import java.io.Serializable
-
-class ConfigurationExtractor(private val project: Project) {
-    fun extractConfiguration(sourceSetName: String): PlatformData? {
-        val projectExtension = project.extensions.findByType(KotlinProjectExtension::class.java) ?: run {
-            project.logger.error("Missing kotlin project extension")
-            return null
-        }
-
-        val sourceSet = projectExtension.sourceSets.findByName(sourceSetName) ?: run {
-            project.logger.error("No source set with name '$sourceSetName' found")
-            return null
-        }
-
-        val compilation = try {
-            when (projectExtension) {
-                is KotlinMultiplatformExtension -> {
-                    val targets = projectExtension.targets.flatMap { it.compilations }
-                    targets.find { it.name == sourceSetName }
-                        ?: targets.find { it.kotlinSourceSets.contains(sourceSet) }
-                }
-                is KotlinSingleTargetExtension -> projectExtension.target.compilations.find {
-                    it.kotlinSourceSets.contains(sourceSet)
-                }
-                else -> null
-            }
-        } catch (e: NoClassDefFoundError) { // Old Kotlin plugin versions
-            null
-        }
-
-        val sourceRoots = sourceSet.sourceFiles
-        val classpath = compilation?.classpath
-            ?: sourceRoots + sourceSet.allParentSourceFiles()
-
-        return PlatformData(
-            sourceSetName,
-            classpath.filter { it.exists() },
-            sourceRoots,
-            sourceSet.dependsOn.map { it.name },
-            compilation?.target?.platformType?.name ?: "common"
-        )
-    }
-
-    private fun KotlinSourceSet.allParentSourceFiles(): List<File> =
-        sourceFiles + dependsOn.flatMap { it.allParentSourceFiles() }
-
-    fun extractFromJavaPlugin(): PlatformData? =
-        project.convention.findPlugin(JavaPluginConvention::class.java)
-            ?.run { sourceSets.findByName(SourceSet.MAIN_SOURCE_SET_NAME)?.allSource?.srcDirs }
-            ?.let { PlatformData(null, emptyList(), it.toList(), emptyList(), "") }
-
-    fun extractFromKotlinTasks(kotlinTasks: List<Task>): List<PlatformData> =
-        try {
-            kotlinTasks.map { extractFromKotlinTask(it) }
-        } catch (e: Throwable) {
-            when (e) {
-                is UnknownDomainObjectException, is NoClassDefFoundError, is ClassNotFoundException ->
-                    listOfNotNull(extractFromKotlinTasksTheHardWay(kotlinTasks))
-                else -> throw e
-            }
-        }
-
-    private fun extractFromKotlinTask(task: Task): PlatformData =
-        try {
-            project.extensions.getByType(KotlinSingleTargetExtension::class.java).target
-                .compilations
-                .find { it.compileKotlinTask == task }
-        } catch (e: Throwable) {
-            when (e) {
-                is UnknownDomainObjectException, is NoClassDefFoundError, is ClassNotFoundException ->
-                    project.extensions.getByType(KotlinMultiplatformExtension::class.java).targets
-                        .flatMap { it.compilations }.firstOrNull { it.compileKotlinTask == task }
-                else -> throw e
-            }
-        }.let { compilation ->
-            PlatformData(
-                task.name,
-                compilation?.classpath.orEmpty(),
-                compilation?.sourceFiles.orEmpty(),
-                compilation?.dependentSourceSets?.map { it.name }.orEmpty(),
-                compilation?.platformType?.toString() ?: ""
-            )
-        }
-
-    private fun extractFromKotlinTasksTheHardWay(kotlinTasks: List<Task>): PlatformData? {
-        val allClasspath = mutableSetOf<File>()
-        var allClasspathFileCollection: FileCollection = project.files()
-        val allSourceRoots = mutableSetOf<File>()
-
-        kotlinTasks.forEach {
-            with(ReflectDsl) {
-                val taskSourceRoots: List<File>
-                val abstractKotlinCompileClz: Class<out Any>
-                try {
-                    taskSourceRoots = it["sourceRootsContainer"]["sourceRoots"].v()
-                    abstractKotlinCompileClz = DokkaTask.getAbstractKotlinCompileFor(it)!!
-                } catch (e: NullPointerException) {
-                    println("Error during extraction of sources from kotlinTasks. This may be a result of outdated Kotlin Gradle Plugin")
-                    return null
-                }
-
-                val taskClasspath: Iterable<File> =
-                    (it["getClasspath", AbstractCompile::class].takeIfIsFunc()?.invoke()
-                        ?: it["compileClasspath", abstractKotlinCompileClz].takeIfIsProp()?.v()
-                        ?: it["getClasspath", abstractKotlinCompileClz]())
-
-                if (taskClasspath is FileCollection) {
-                    allClasspathFileCollection += taskClasspath
-                } else {
-                    allClasspath += taskClasspath
-                }
-                allSourceRoots += taskSourceRoots.filter { it.exists() }
-            }
-        }
-        val classpath: MutableList<File> = try {
-            allClasspathFileCollection.toMutableList()
-        } catch (e: ResolveException) {
-            mutableListOf()
-        }
-        classpath.addAll(project.files(allClasspath).toList())
-
-        return PlatformData(null, classpath, allSourceRoots.toList(), emptyList(), "")
-    }
-
-    private val KotlinCompilation<*>.sourceFiles: List<File>
-        get() = kotlinSourceSets.flatMap { it.sourceFiles }
-
-    private val KotlinSourceSet.sourceFiles: List<File>
-        get() = kotlin.sourceDirectories.filter { it.exists() }.toList()
-
-    private val KotlinCompilation<*>.dependentSourceSets: Set<KotlinSourceSet>
-        get() = (allKotlinSourceSets - kotlinSourceSets)
-
-    private val KotlinCompilation<*>.classpath: List<File>
-        get() = if (target.isAndroidTarget()) {
-            getClasspathFromAndroidTask(this)
-        } else {
-            getClasspathFromRegularTask(this)
-        }
-
-    // This is a workaround for KT-33893
-    private fun getClasspathFromAndroidTask(compilation: KotlinCompilation<*>): List<File> = (compilation
-        .compileKotlinTask as? KotlinCompile)
-        ?.classpath?.files?.toList() ?: getClasspathFromRegularTask(compilation)
-
-    private fun getClasspathFromRegularTask(compilation: KotlinCompilation<*>): List<File> {
-        // explicit dependencies of the compilation
-        val ownDependencyFiles: Set<File> = compilation.compileDependencyFiles.files
-
-        // the dependencies provided by the platform (e.g. Kotlin/Native platform libs)
-        val platformDependencyFiles: Set<File> = (compilation as? KotlinNativeCompilation)
-            ?.target?.project?.configurations
-            ?.findByName(compilation.defaultSourceSet.implementationMetadataConfigurationName)?.files
-            ?: emptySet()
-
-        return (ownDependencyFiles + platformDependencyFiles).toList().filter { it.exists() }
-    }
-
-    data class PlatformData(
-        val name: String?,
-        val classpath: List<File>,
-        val sourceRoots: List<File>,
-        val dependentSourceSets: List<String>,
-        val platform: String
-    ) : Serializable
-}
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
index 8d337795..7a73d633 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
@@ -1,59 +1,24 @@
 package org.jetbrains.dokka.gradle
 
-import com.google.gson.GsonBuilder
-import org.gradle.api.plugins.JavaBasePlugin.DOCUMENTATION_GROUP
-import org.gradle.api.tasks.Input
-import org.jetbrains.dokka.toJsonString
-
-open class DokkaCollectorTask : AbstractDokkaTask() {
-
-    @Input
-    var modules: List<String> = emptyList()
-
-    @Input
-    var dokkaTaskNames: Set<String> = setOf()
-
-    override fun generate() {
-        val configurations = getSubprojectDokkaTasks(dokkaTaskNames)
-            .mapNotNull { dokkaTask -> dokkaTask.getConfigurationOrNull() }
-
-        val initial = GradleDokkaConfigurationImpl().apply {
-            outputDir = outputDirectory
-            cacheRoot = configurations.first().cacheRoot
-        }
-
-        val configuration = configurations.fold(initial) { acc, it: GradleDokkaConfigurationImpl ->
-            if (acc.cacheRoot != it.cacheRoot)
-                throw IllegalStateException("Dokka task configurations differ on core argument cacheRoot")
-            acc.sourceSets = acc.sourceSets + it.sourceSets
-            acc.pluginsClasspath = (acc.pluginsClasspath + it.pluginsClasspath).distinct()
-            acc
+import org.jetbrains.dokka.DokkaConfigurationImpl
+
+open class DokkaCollectorTask : AbstractDokkaParentTask() {
+
+    override fun buildDokkaConfiguration(): DokkaConfigurationImpl {
+        val initialDokkaConfiguration = DokkaConfigurationImpl(
+            outputDir = outputDirectory,
+            cacheRoot = cacheRoot,
+            failOnWarning = failOnWarning,
+            offlineMode = offlineMode,
+            pluginsClasspath = plugins.resolve().toList(),
+        )
+
+        val subprojectDokkaConfigurations = dokkaTasks.map { dokkaTask -> dokkaTask.buildDokkaConfiguration() }
+        return subprojectDokkaConfigurations.fold(initialDokkaConfiguration) { acc, it: DokkaConfigurationImpl ->
+            acc.copy(
+                sourceSets = acc.sourceSets + it.sourceSets,
+                pluginsClasspath = acc.pluginsClasspath + it.pluginsClasspath
+            )
         }
-
-        val bootstrap = DokkaBootstrap("org.jetbrains.dokka.DokkaBootstrapImpl")
-        bootstrap.configure(configuration.toJsonString()) { level, message ->
-            when (level) {
-                "debug" -> logger.debug(message)
-                "info" -> logger.info(message)
-                "progress" -> logger.lifecycle(message)
-                "warn" -> logger.warn(message)
-                "error" -> logger.error(message)
-            }
-        }
-        bootstrap.generate()
-    }
-
-    private fun getSubprojectDokkaTasks(dokkaTaskName: String): List<DokkaTask> {
-        return project.subprojects
-            .filter { subproject -> subproject.name in modules }
-            .mapNotNull { subproject -> subproject.tasks.findByName(dokkaTaskName) as? DokkaTask }
-    }
-
-    private fun getSubprojectDokkaTasks(dokkaTaskNames: Set<String>): List<DokkaTask> {
-        return dokkaTaskNames.flatMap { dokkaTaskName -> getSubprojectDokkaTasks(dokkaTaskName) }
-    }
-
-    init {
-        group = DOCUMENTATION_GROUP
     }
 }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultimoduleTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultimoduleTask.kt
index 986b883a..8369954b 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultimoduleTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultimoduleTask.kt
@@ -1,66 +1,40 @@
 package org.jetbrains.dokka.gradle
 
-import org.gradle.api.plugins.JavaBasePlugin.DOCUMENTATION_GROUP
+import org.gradle.api.internal.tasks.TaskDependencyInternal
 import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.Internal
+import org.jetbrains.dokka.DokkaConfigurationImpl
+import org.jetbrains.dokka.DokkaModuleDescriptionImpl
+import org.jetbrains.dokka.DokkaMultimoduleBootstrapImpl
 import org.jetbrains.dokka.plugability.Configurable
-import org.jetbrains.dokka.toJsonString
 
-open class DokkaMultimoduleTask : AbstractDokkaTask(), Configurable {
+open class DokkaMultimoduleTask : AbstractDokkaParentTask(DokkaMultimoduleBootstrapImpl::class), Configurable {
 
+    /**
+     * Name of the file containing all necessary module information.
+     * This file has to be placed inside the subrpojects root directory.
+     */
     @Input
     var documentationFileName: String = "README.md"
 
-
-    @Input
-    var dokkaTaskNames: Set<String> = setOf()
-        set(value) {
-            field = value.toSet()
-            setDependsOn(getSubprojectDokkaTasks(value))
-        }
-
-
-    override fun generate() {
-        val bootstrap = DokkaBootstrap("org.jetbrains.dokka.DokkaMultimoduleBootstrapImpl")
-        val configuration = getConfiguration()
-        bootstrap.configure(configuration.toJsonString()) { level, message ->
-            when (level) {
-                "debug" -> logger.debug(message)
-                "info" -> logger.info(message)
-                "progress" -> logger.lifecycle(message)
-                "warn" -> logger.warn(message)
-                "error" -> logger.error(message)
-            }
-        }
-        bootstrap.generate()
+    override fun getTaskDependencies(): TaskDependencyInternal {
+        return super.getTaskDependencies() + dokkaTasks
     }
 
-    @Internal
-    internal fun getConfiguration(): GradleDokkaConfigurationImpl =
-        GradleDokkaConfigurationImpl().apply {
-            outputDir = project.file(outputDirectory).absolutePath
-            pluginsClasspath = plugins.resolve().toList()
-            pluginsConfiguration = this@DokkaMultimoduleTask.pluginsConfiguration
-            modules = getSubprojectDokkaTasks(dokkaTaskNames).map { dokkaTask ->
-                GradleDokkaModuleDescription().apply {
-                    name = dokkaTask.project.name
-                    path = dokkaTask.project.projectDir.resolve(dokkaTask.outputDirectory)
-                        .toRelativeString(project.file(outputDirectory))
-                    docFile = dokkaTask.project.projectDir.resolve(documentationFileName).absolutePath
-                }
+    override fun buildDokkaConfiguration(): DokkaConfigurationImpl {
+        return DokkaConfigurationImpl(
+            outputDir = outputDirectory,
+            cacheRoot = cacheRoot,
+            pluginsConfiguration = pluginsConfiguration,
+            failOnWarning = failOnWarning,
+            offlineMode = offlineMode,
+            pluginsClasspath = plugins.resolve().toList(),
+            modules = dokkaTasks.map { dokkaTask ->
+                DokkaModuleDescriptionImpl(
+                    name = dokkaTask.project.name,
+                    path = dokkaTask.outputDirectory.relativeTo(outputDirectory),
+                    docFile = dokkaTask.project.projectDir.resolve(documentationFileName).absoluteFile
+                )
             }
-        }
-
-    private fun getSubprojectDokkaTasks(dokkaTaskName: String): List<DokkaTask> {
-        return project.subprojects
-            .mapNotNull { subproject -> subproject.tasks.findByName(dokkaTaskName) as? DokkaTask }
-    }
-
-    private fun getSubprojectDokkaTasks(dokkaTaskNames: Set<String>): List<DokkaTask> {
-        return dokkaTaskNames.flatMap { dokkaTaskName -> getSubprojectDokkaTasks(dokkaTaskName) }
-    }
-
-    init {
-        group = DOCUMENTATION_GROUP
+        )
     }
 }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/j