Extract HTML plugin from base one

core/api/core.api

@@ -242,8 +242,8 @@ public class org/jetbrains/dokka/DokkaException : java/lang/RuntimeException {
 public final class org/jetbrains/dokka/DokkaGenerator {
 	public fun <init> (Lorg/jetbrains/dokka/DokkaConfiguration;Lorg/jetbrains/dokka/utilities/DokkaLogger;)V
 	public final fun generate ()V
-	public final fun initializePlugins (Lorg/jetbrains/dokka/DokkaConfiguration;Lorg/jetbrains/dokka/utilities/DokkaLogger;Ljava/util/List;)Lorg/jetbrains/dokka/plugability/DokkaContext;
-	public static synthetic fun initializePlugins$default (Lorg/jetbrains/dokka/DokkaGenerator;Lorg/jetbrains/dokka/DokkaConfiguration;Lorg/jetbrains/dokka/utilities/DokkaLogger;Ljava/util/List;ILjava/lang/Object;)Lorg/jetbrains/dokka/plugability/DokkaContext;
+	public final fun initializePlugins (Lorg/jetbrains/dokka/DokkaConfiguration;Lorg/jetbrains/dokka/utilities/DokkaLogger;Ljava/util/List;Z)Lorg/jetbrains/dokka/plugability/DokkaContext;
+	public static synthetic fun initializePlugins$default (Lorg/jetbrains/dokka/DokkaGenerator;Lorg/jetbrains/dokka/DokkaConfiguration;Lorg/jetbrains/dokka/utilities/DokkaLogger;Ljava/util/List;ZILjava/lang/Object;)Lorg/jetbrains/dokka/plugability/DokkaContext;
 }
 
 public final class org/jetbrains/dokka/DokkaModuleDescriptionImpl : org/jetbrains/dokka/DokkaConfiguration$DokkaModuleDescription {
@@ -4348,7 +4348,8 @@ public abstract interface class org/jetbrains/dokka/plugability/DokkaContext {
 }
 
 public final class org/jetbrains/dokka/plugability/DokkaContext$Companion {
-	public final fun create (Lorg/jetbrains/dokka/DokkaConfiguration;Lorg/jetbrains/dokka/utilities/DokkaLogger;Ljava/util/List;)Lorg/jetbrains/dokka/plugability/DokkaContext;
+	public final fun create (Lorg/jetbrains/dokka/DokkaConfiguration;Lorg/jetbrains/dokka/utilities/DokkaLogger;Ljava/util/List;Z)Lorg/jetbrains/dokka/plugability/DokkaContext;
+	public static synthetic fun create$default (Lorg/jetbrains/dokka/plugability/DokkaContext$Companion;Lorg/jetbrains/dokka/DokkaConfiguration;Lorg/jetbrains/dokka/utilities/DokkaLogger;Ljava/util/List;ZILjava/lang/Object;)Lorg/jetbrains/dokka/plugability/DokkaContext;
 }
 
 public abstract interface class org/jetbrains/dokka/plugability/DokkaContextConfiguration {

core/src/main/kotlin/DokkaGenerator.kt

@@ -39,8 +39,9 @@ class DokkaGenerator(
     fun initializePlugins(
         configuration: DokkaConfiguration,
         logger: DokkaLogger,
-        additionalPlugins: List<DokkaPlugin> = emptyList()
-    ) = DokkaContext.create(configuration, logger, additionalPlugins)
+        additionalPlugins: List<DokkaPlugin> = emptyList(),
+        ignorePluginsFromClassLoader: Boolean = false
+    ) = DokkaContext.create(configuration, logger, additionalPlugins, ignorePluginsFromClassLoader)
 
     @OptIn(DelicateCoroutinesApi::class)
     private fun finalizeCoroutines() {

core/src/main/kotlin/plugability/DokkaContext.kt

@@ -24,17 +24,22 @@ interface DokkaContext {
         fun create(
             configuration: DokkaConfiguration,
             logger: DokkaLogger,
-            pluginOverrides: List<DokkaPlugin>
+            pluginOverrides: List<DokkaPlugin>,
+            ignorePluginsFromClassLoader: Boolean = false
         ): DokkaContext =
             DokkaContextConfigurationImpl(logger, configuration).apply {
-                // File(it.path) is a workaround for an incorrect filesystem in a File instance returned by Gradle.
-                configuration.pluginsClasspath.map { File(it.path).toURI().toURL() }
-                    .toTypedArray()
-                    .let { URLClassLoader(it, this.javaClass.classLoader) }
-                    .also { checkClasspath(it) }
-                    .let { ServiceLoader.load(DokkaPlugin::class.java, it) }
-                    .let { it + pluginOverrides }
-                    .forEach { install(it) }
+                if(ignorePluginsFromClassLoader) {
+                    pluginOverrides.forEach { install(it) }
+                } else {
+                    // File(it.path) is a workaround for an incorrect filesystem in a File instance returned by Gradle.
+                    configuration.pluginsClasspath.map { File(it.path).toURI().toURL() }
+                        .toTypedArray()
+                        .let { URLClassLoader(it, this.javaClass.classLoader) }
+                        .also { checkClasspath(it) }
+                        .let { ServiceLoader.load(DokkaPlugin::class.java, it) }
+                        .let { it + pluginOverrides }
+                        .forEach { install(it) }
+                }
                 topologicallySortAndPrune()
             }.also { it.logInitialisationInfo() }
     }

gradle.properties

@@ -17,5 +17,5 @@ freemarker_version=2.3.31
 # Code style
 kotlin.code.style=official
 # Gradle settings
-org.gradle.jvmargs=-Xmx6g -XX:MaxMetaspaceSize=2g
+org.gradle.jvmargs=-Xmx8g -XX:MaxMetaspaceSize=2g
 org.gradle.parallel=true

integration-tests/cli/build.gradle.kts

@@ -8,6 +8,7 @@ plugins {
 val dokka_version: String by project
 evaluationDependsOn(":runners:cli")
 evaluationDependsOn(":plugins:base")
+evaluationDependsOn(":plugins:html")
 
 dependencies {
     implementation(kotlin("stdlib"))
@@ -21,22 +22,37 @@ val basePluginShadow: Configuration by configurations.creating {
     }
 }
 
+val htmlPluginShadow: Configuration by configurations.creating {
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage::class.java, "java-runtime"))
+    }
+}
+
 dependencies {
     basePluginShadow(project(":plugins:base"))
     basePluginShadow(project(":kotlin-analysis")) // compileOnly in base plugin
+    htmlPluginShadow(project(":plugins:html"))
 }
+
 val basePluginShadowJar by tasks.register("basePluginShadowJar", ShadowJar::class) {
     configurations = listOf(basePluginShadow)
     archiveFileName.set("fat-base-plugin-$dokka_version.jar")
     archiveClassifier.set("")
 }
+val htmlPluginShadowJar by tasks.register("htmlPluginShadowJar", ShadowJar::class) {
+    configurations = listOf(htmlPluginShadow)
+    archiveFileName.set("fat-html-plugin-$dokka_version.jar")
+    archiveClassifier.set("")
+}
 
 tasks.integrationTest {
     inputs.dir(file("projects"))
     val cliJar = tasks.getByPath(":runners:cli:shadowJar") as ShadowJar
     environment("CLI_JAR_PATH", cliJar.archiveFile.get())
+    environment("HTML_PLUGIN_JAR_PATH", htmlPluginShadowJar.archiveFile.get())
     environment("BASE_PLUGIN_JAR_PATH", basePluginShadowJar.archiveFile.get())
     dependsOn(cliJar)
     dependsOn(basePluginShadowJar)
+    dependsOn(htmlPluginShadowJar)
 }
 

integration-tests/cli/src/integrationTest/kotlin/org/jetbrains/dokka/it/cli/CliIntegrationTest.kt

@@ -8,6 +8,10 @@ import kotlin.test.*
 
 class CliIntegrationTest : AbstractCliIntegrationTest() {
 
+    val pluginClasspath by lazy {
+        listOf(basePluginJarFile, htmlPluginJarFile).joinToString(separator = ";") { it.path }
+    }
+
     @BeforeTest
     fun copyProject() {
         val templateProjectDir = File("projects", "it-cli")
@@ -32,7 +36,7 @@ class CliIntegrationTest : AbstractCliIntegrationTest() {
         val process = ProcessBuilder(
             "java", "-jar", cliJarFile.path,
             "-outputDir", dokkaOutputDir.path,
-            "-pluginsClasspath", basePluginJarFile.path,
+            "-pluginsClasspath", pluginClasspath,
             "-moduleName", "Basic Project",
             "-sourceSet",
             buildString {
@@ -107,7 +111,7 @@ class CliIntegrationTest : AbstractCliIntegrationTest() {
         val process = ProcessBuilder(
             "java", "-jar", cliJarFile.path,
             "-outputDir", dokkaOutputDir.path,
-            "-pluginsClasspath", basePluginJarFile.path,
+            "-pluginsClasspath", pluginClasspath,
             "-moduleName", "Basic Project",
             "-failOnWarning",
             "-sourceSet",
@@ -135,7 +139,7 @@ class CliIntegrationTest : AbstractCliIntegrationTest() {
         val process = ProcessBuilder(
             "java", "-jar", cliJarFile.path,
             "-outputDir", dokkaOutputDir.path,
-            "-pluginsClasspath", basePluginJarFile.path,
+            "-pluginsClasspath", pluginClasspath,
             "-moduleName", "Basic Project",
             "-sourceSet",
             buildString {
@@ -166,7 +170,7 @@ class CliIntegrationTest : AbstractCliIntegrationTest() {
             "java", "-jar", cliJarFile.path,
             "-outputDir", dokkaOutputDir.path,
             "-loggingLevel", "DEBUG",
-            "-pluginsClasspath", basePluginJarFile.path,
+            "-pluginsClasspath", pluginClasspath,
             "-sourceSet",
             buildString {
                 append(" -src ${File(projectDir, "src").path}")
@@ -202,7 +206,7 @@ class CliIntegrationTest : AbstractCliIntegrationTest() {
             "java", "-jar", cliJarFile.path,
             "-outputDir", dokkaOutputDir.path,
             "-loggingLevel", "WARN",
-            "-pluginsClasspath", basePluginJarFile.path,
+            "-pluginsClasspath", pluginClasspath,
             "-sourceSet",
             buildString {
                 append(" -src ${File(projectDir, "src").path}")
@@ -223,7 +227,7 @@ class CliIntegrationTest : AbstractCliIntegrationTest() {
         val process = ProcessBuilder(
             "java", "-jar", cliJarFile.path,
             "-outputDir", dokkaOutputDir.path,
-            "-pluginsClasspath", basePluginJarFile.path,
+            "-pluginsClasspath", pluginClasspath,
             "-moduleName", "Basic Project",
             "-sourceSet",
             buildString {
@@ -270,7 +274,13 @@ class CliIntegrationTest : AbstractCliIntegrationTest() {
         val resourcePath = javaClass.getResource("/my-file.json")?.toURI() ?: throw IllegalStateException("No JSON found!")
         val jsonPath = File(resourcePath).absolutePath
         PrintWriter(jsonPath).run {
-            write(jsonBuilder(dokkaOutputDir.invariantSeparatorsPath, basePluginJarFile.invariantSeparatorsPath, File(projectDir, "src").invariantSeparatorsPath, reportUndocumented = true))
+            write(
+                jsonBuilder(
+                    outputPath = dokkaOutputDir.invariantSeparatorsPath,
+                    pluginsClasspath = "\"${basePluginJarFile.invariantSeparatorsPath}\", \"${htmlPluginJarFile.invariantSeparatorsPath}\"",
+                    projectPath = File(projectDir, "src").invariantSeparatorsPath, reportUndocumented = true
+                )
+            )
             close()
         }
 
@@ -313,7 +323,7 @@ class CliIntegrationTest : AbstractCliIntegrationTest() {
             write(
                 jsonBuilder(
                     outputPath = dokkaOutputDir.invariantSeparatorsPath,
-                    pluginsClasspath = basePluginJarFile.invariantSeparatorsPath,
+                    pluginsClasspath = "\"${basePluginJarFile.invariantSeparatorsPath}\", \"${htmlPluginJarFile.invariantSeparatorsPath}\"",
                     projectPath = File(projectDir, "src").invariantSeparatorsPath,
                     globalSourceLinks = """
                         {

integration-tests/cli/src/integrationTest/kotlin/org/jetbrains/dokka/it/cli/jsonBuilder.kt

@@ -14,7 +14,7 @@ fun jsonBuilder(
   "moduleName": "Dokka Example",
   "moduleVersion": null,
   "outputDir": "$outputPath",
-  "pluginsClasspath": ["$pluginsClasspath"],
+  "pluginsClasspath": [$pluginsClasspath],
   "cacheRoot": null,
   "offlineMode": false,
   "sourceLinks": [$globalSourceLinks],

integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/AbstractCliIntegrationTest.kt

@@ -15,6 +15,10 @@ abstract class AbstractCliIntegrationTest : AbstractIntegrationTest() {
         File(temporaryTestFolder.root, "base-plugin.jar")
     }
 
+    protected val htmlPluginJarFile: File by lazy {
+        File(temporaryTestFolder.root, "html-plugin.jar")
+    }
+
     @BeforeTest
     fun copyJarFiles() {
         val cliJarPathEnvironmentKey = "CLI_JAR_PATH"
@@ -32,5 +36,13 @@ abstract class AbstractCliIntegrationTest : AbstractIntegrationTest() {
             "Missing path to base plugin jar System.getenv($basePluginPathEnvironmentKey)"
         )
         basePluginJarFile.copyTo(this.basePluginJarFile)
+
+        val htmlPluginPathEnvironmentKey = "HTML_PLUGIN_JAR_PATH"
+        val htmlPluginJarFile = File(System.getenv(htmlPluginPathEnvironmentKey))
+        assertTrue(
+            htmlPluginJarFile.exists() && htmlPluginJarFile.isFile,
+            "Missing path to html plugin jar System.getenv($htmlPluginPathEnvironmentKey)"
+        )
+        htmlPluginJarFile.copyTo(this.htmlPluginJarFile)
     }
 }

integration-tests/gradle/projects/stdlib/plugins/dokka-samples-transformer-plugin/build.gradle

@@ -9,7 +9,7 @@ repositories {
 }
 
 dependencies {
-    implementation "org.jetbrains.dokka:dokka-base:${dokka_it_version}"
+    implementation "org.jetbrains.dokka:html-plugin:${dokka_it_version}"
     compileOnly "org.jetbrains.dokka:dokka-core:${dokka_it_version}"
     compileOnly "org.jetbrains.dokka:dokka-analysis:${dokka_it_version}"
 }

integration-tests/gradle/projects/stdlib/plugins/dokka-samples-transformer-plugin/src/main/kotlin/org/jetbrains/dokka/kotlinlang/SamplesTransformerPlugin.kt

@@ -1,14 +1,14 @@
 package org.jetbrains.dokka.kotlinlang
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.html.DokkaHtml
 import org.jetbrains.dokka.plugability.DokkaPlugin
 
 class SamplesTransformerPlugin : DokkaPlugin() {
-    private val dokkaBase by lazy { plugin<DokkaBase>() }
+    private val dokkaHtml by lazy { plugin<DokkaHtml>() }
 
     val kotlinWebsiteSamplesTransformer by extending {
-        CoreExtensions.pageTransformer providing ::KotlinWebsiteSamplesTransformer override dokkaBase.defaultSamplesTransformer order {
+        CoreExtensions.pageTransformer providing ::KotlinWebsiteSamplesTransformer override dokkaHtml.defaultSamplesTransformer order {
             before(dokkaBase.pageMerger)
         }
     }

integration-tests/gradle/projects/stdlib/plugins/dokka-stdlib-configuration-plugin/build.gradle

@@ -9,9 +9,9 @@ repositories {
 }
 
 dependencies {
-    implementation "org.jetbrains.dokka:dokka-base:${dokka_it_version}"
-    compileOnly "org.jetbrains.dokka:dokka-core:${dokka_it_version}"
-    compileOnly "org.jetbrains.dokka:dokka-analysis:${dokka_it_version}"
+    implementation "org.jetbrains.dokka:dokka-base:1.5.0" // ${dokka_it_version} - old Gradle does not support latest Dokka
+    compileOnly "org.jetbrains.dokka:dokka-core:1.5.0"// ${dokka_it_version}
+    compileOnly "org.jetbrains.dokka:dokka-analysis:1.5.0" // ${dokka_it_version}
 }
 
 tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile) {

integration-tests/gradle/projects/stdlib/stdlib.diff

@@ -37,7 +37,7 @@ diff --git a/build.gradle b/build.gradle
 index aa8f21b..dd6a2ae 100644
 --- a/build.gradle
 +++ b/build.gradle
-@@ -1,80 +1,445 @@
+@@ -1,80 +1,446 @@
 +import org.jetbrains.dokka.Platform
 +
  plugins {
@@ -76,8 +76,9 @@ index aa8f21b..dd6a2ae 100644
 
  dependencies {
 -  dokka "org.jetbrains.dokka:dokka-fatjar:$dokka_version"
-+  dokkaPlugin project(":plugins:dokka-samples-transformer-plugin")
++  // dokkaPlugin project(":plugins:dokka-samples-transformer-plugin") uncomment after upgrade StdLib Gradle
 +  dokkaPlugin project(":plugins:dokka-stdlib-configuration-plugin")
++  dokkaPlugin "org.jetbrains.dokka:html-plugin:$dokka_it_version"
  }
 
 -final File dokkaHome = new File(buildDir, "dokka-home")

integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/kotlin/StdlibGradleIntegrationTest.kt

@@ -24,7 +24,7 @@ class StdlibGradleIntegrationTest(override val versions: BuildVersions) : Abstra
 
     override val projectOutputLocation: File by lazy { File(projectDir, "build/dokka/kotlin-stdlib") }
 
-    private val currentDokkaVersion: String = "1.5.0"//checkNotNull(System.getenv("DOKKA_VERSION")) // uncomment after updating of StdLib
+    private val currentDokkaVersion: String = checkNotNull(System.getenv("DOKKA_VERSION"))
 
     @BeforeTest
     fun prepareProjectFiles() {

kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt

@@ -30,7 +30,7 @@ internal fun createEnvironmentAndFacade(
         val environment = createCoreEnvironment()
 
         val (facade, _) = createResolutionFacade(environment, analysisConfiguration.ignoreCommonBuiltIns)
-        EnvironmentAndFacade(environment, facade)
+        EnvironmentAndFacade(environment, facade, this)
     }
 
 class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
@@ -51,7 +51,12 @@ class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector
 }
 
 // It is not data class due to ill-defined equals
-class EnvironmentAndFacade(val environment: KotlinCoreEnvironment, val facade: DokkaResolutionFacade) {
+class EnvironmentAndFacade(val environment: KotlinCoreEnvironment, val facade: DokkaResolutionFacade, val analysisEnvironment: AnalysisEnvironment) {
     operator fun component1() = environment
     operator fun component2() = facade
+    operator fun component3() = analysisEnvironment
+
+    protected fun finalize() {
+        analysisEnvironment.dispose()
+    }
 }

plugins/all-modules-page/build.gradle.kts

@@ -9,6 +9,7 @@ dependencies {
     implementation(project(":plugins:base"))
     implementation(project(":plugins:templating"))
     testImplementation(project(":plugins:base"))
+    testImplementation(project(":plugins:html"))
     testImplementation(project(":plugins:base:base-test-utils"))
     testImplementation(project(":plugins:gfm"))
     testImplementation(project(":plugins:gfm:gfm-template-processing"))

plugins/all-modules-page/src/test/kotlin/MultiModuleDokkaTestGenerator.kt

@@ -3,9 +3,11 @@ package org.jetbrains.dokka.allModulesPage
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.DokkaGenerator
+import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.templates.TemplatingPlugin
 import org.jetbrains.dokka.testApi.logger.TestLogger
 import org.jetbrains.dokka.testApi.testRunner.AbstractTest
 import org.jetbrains.dokka.testApi.testRunner.DokkaTestGenerator
@@ -29,7 +31,12 @@ class MultiModuleDokkaTestGenerator(
         val dokkaGenerator = DokkaGenerator(configuration, logger)
 
         val context =
-            dokkaGenerator.initializePlugins(configuration, logger, additionalPlugins + AllModulesPagePlugin())
+            dokkaGenerator.initializePlugins(
+                configuration = configuration,
+                logger = logger,
+                additionalPlugins = additionalPlugins + listOf(AllModulesPagePlugin(), DokkaBase(), TemplatingPlugin()),
+                ignorePluginsFromClassLoader = true // in classloader we have a conflict HTML and GFM plugins
+            )
         pluginsSetupStage(context)
 
         val generation = context.single(CoreExtensions.generation) as AllModulesPageGeneration

plugins/all-modules-page/src/test/kotlin/templates/MultiModuleDocumentationTest.kt

@@ -2,6 +2,7 @@ package org.jetbrains.dokka.allModulesPage.templates
 
 import matchers.content.*
 import org.jetbrains.dokka.allModulesPage.MultiModuleAbstractTest
+import org.jetbrains.dokka.html.DokkaHtml
 import org.jetbrains.dokka.model.dfs
 import org.jetbrains.dokka.pages.ContentKind
 import org.jetbrains.dokka.pages.ContentResolvedLink
@@ -39,7 +40,10 @@ class MultiModuleDocumentationTest : MultiModuleAbstractTest() {
             includes = listOf(folder.root.resolve("README.md"))
         }
 
-        testFromData(configuration) {
+        testFromData(
+            configuration,
+            pluginOverrides = listOf(DokkaHtml())
+        ) {
             allModulesPageCreationStage = { rootPage ->
                 (rootPage as? MultimoduleRootPageNode)?.content?.dfs { it.dci.kind == ContentKind.Cover }?.children?.firstOrNull()
                     ?.assertNode {