Moving SingleGeneration to base pluing

2 files changed, 121 insertions, 9 deletions

diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index fce5c399..ac070ab4 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -16,7 +16,6 @@ import org.jetbrains.dokka.base.resolvers.local.LocationProviderFactory
 import org.jetbrains.dokka.base.resolvers.shared.RecognizedLinkFormat
 import org.jetbrains.dokka.base.signatures.KotlinSignatureProvider
 import org.jetbrains.dokka.base.signatures.SignatureProvider
-import org.jetbrains.dokka.base.templating.Command
 import org.jetbrains.dokka.base.templating.ImmediateHtmlCommandConsumer
 import org.jetbrains.dokka.base.transformers.documentables.*
 import org.jetbrains.dokka.base.transformers.pages.annotations.SinceKotlinTransformer
@@ -28,10 +27,14 @@ import org.jetbrains.dokka.base.transformers.pages.sourcelinks.SourceLinksTransf
 import org.jetbrains.dokka.base.translators.descriptors.DefaultDescriptorToDocumentableTranslator
 import org.jetbrains.dokka.base.translators.documentables.DefaultDocumentableToPageTranslator
 import org.jetbrains.dokka.base.translators.psi.DefaultPsiToDocumentableTranslator
+import org.jetbrains.dokka.base.generation.SingleModuleGeneration
 import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 import org.jetbrains.dokka.transformers.pages.PageTransformer
 
 class DokkaBase : DokkaPlugin() {
+
+    val preMergeDocumentableTransformer by extensionPoint<PreMergeDocumentableTransformer>()
     val pageMergerStrategy by extensionPoint<PageMergerStrategy>()
     val commentsToContentConverter by extensionPoint<CommentsToContentConverter>()
     val signatureProvider by extensionPoint<SignatureProvider>()
@@ -43,6 +46,10 @@ class DokkaBase : DokkaPlugin() {
     val tabSortingStrategy by extensionPoint<TabSortingStrategy>()
     val immediateHtmlCommandConsumer by extensionPoint<ImmediateHtmlCommandConsumer>()
 
+    val singleGeneration by extending {
+        CoreExtensions.generation providing ::SingleModuleGeneration
+    }
+
     val descriptorToDocumentableTranslator by extending {
         CoreExtensions.sourceToDocumentableTranslator providing ::DefaultDescriptorToDocumentableTranslator
     }
@@ -56,29 +63,29 @@ class DokkaBase : DokkaPlugin() {
     }
 
     val deprecatedDocumentableFilter by extending {
-        CoreExtensions.preMergeDocumentableTransformer providing ::DeprecatedDocumentableFilterTransformer
+        preMergeDocumentableTransformer providing ::DeprecatedDocumentableFilterTransformer
     }
 
     val suppressedDocumentableFilter by extending {
-        CoreExtensions.preMergeDocumentableTransformer providing ::SuppressedDocumentableFilterTransformer
+        preMergeDocumentableTransformer providing ::SuppressedDocumentableFilterTransformer
     }
 
     val documentableVisbilityFilter by extending {
-        CoreExtensions.preMergeDocumentableTransformer providing ::DocumentableVisibilityFilterTransformer
+        preMergeDocumentableTransformer providing ::DocumentableVisibilityFilterTransformer
     }
 
     val emptyPackagesFilter by extending {
-        CoreExtensions.preMergeDocumentableTransformer providing ::EmptyPackagesFilterTransformer order {
+        preMergeDocumentableTransformer providing ::EmptyPackagesFilterTransformer order {
             after(deprecatedDocumentableFilter, suppressedDocumentableFilter, documentableVisbilityFilter)
         }
     }
 
-    val actualTypealiasAdder by extending {
-        CoreExtensions.documentableTransformer with ActualTypealiasAdder()
+    val modulesAndPackagesDocumentation by extending {
+        preMergeDocumentableTransformer providing ::ModuleAndPackageDocumentationTransformer
     }
 
-    val modulesAndPackagesDocumentation by extending {
-        CoreExtensions.preMergeDocumentableTransformer providing ::ModuleAndPackageDocumentationTransformer
+    val actualTypealiasAdder by extending {
+        CoreExtensions.documentableTransformer with ActualTypealiasAdder()
     }
 
     val kotlinSignatureProvider by extending {
diff --git a/plugins/base/src/main/kotlin/generation/SingleModuleGeneration.kt b/plugins/base/src/main/kotlin/generation/SingleModuleGeneration.kt
new file mode 100644
index 00000000..eb405a3d
--- /dev/null
+++ b/plugins/base/src/main/kotlin/generation/SingleModuleGeneration.kt
@@ -0,0 +1,105 @@
+
+package org.jetbrains.dokka.base.generation
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaException
+import org.jetbrains.dokka.Timer
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.model.DModule
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.query
+import org.jetbrains.dokka.transformers.sources.AsyncSourceToDocumentableTranslator
+import org.jetbrains.dokka.utilities.parallelMap
+import org.jetbrains.dokka.utilities.report
+
+class SingleModuleGeneration(private val context: DokkaContext) : Generation {
+    override fun Timer.generate() {
+        report("Validity check")
+        validityCheck(context)
+
+        report("Creating documentation models")
+        val modulesFromPlatforms = createDocumentationModels()
+
+        report("Transforming documentation model before merging")
+        val transformedDocumentationBeforeMerge = transformDocumentationModelBeforeMerge(modulesFromPlatforms)
+
+        report("Merging documentation models")
+        val documentationModel = mergeDocumentationModels(transformedDocumentationBeforeMerge)
+
+        report("Transforming documentation model after merging")
+        val transformedDocumentation = transformDocumentationModelAfterMerge(documentationModel)
+
+        report("Creating pages")
+        val pages = createPages(transformedDocumentation)
+
+        report("Transforming pages")
+        val transformedPages = transformPages(pages)
+
+        report("Rendering")
+        render(transformedPages)
+
+        reportAfterRendering()
+    }
+
+    override val generationName = " documentation for ${context.configuration.moduleName}"
+
+    fun createDocumentationModels() = runBlocking(Dispatchers.Default) {
+        context.configuration.sourceSets.parallelMap { sourceSet -> translateSources(sourceSet, context) }.flatten()
+            .also { modules -> if (modules.isEmpty()) exitGenerationGracefully("Nothing to document") }
+    }
+
+    fun transformDocumentationModelBeforeMerge(modulesFromPlatforms: List<DModule>) =
+        context.plugin<DokkaBase>().query { preMergeDocumentableTransformer }.fold(modulesFromPlatforms) { acc, t -> t(acc) }
+
+    fun mergeDocumentationModels(modulesFromPlatforms: List<DModule>) =
+        context.single(CoreExtensions.documentableMerger).invoke(modulesFromPlatforms)
+
+    fun transformDocumentationModelAfterMerge(documentationModel: DModule) =
+        context[CoreExtensions.documentableTransformer].fold(documentationModel) { acc, t -> t(acc, context) }
+
+    fun createPages(transformedDocumentation: DModule) =
+        context.single(CoreExtensions.documentableToPageTranslator).invoke(transformedDocumentation)
+
+    fun transformPages(pages: RootPageNode) =
+        context[CoreExtensions.pageTransformer].fold(pages) { acc, t -> t(acc) }
+
+    fun render(transformedPages: RootPageNode) {
+        context.single(CoreExtensions.renderer).render(transformedPages)
+    }
+
+    fun validityCheck(context: DokkaContext) {
+        val (preGenerationCheckResult, checkMessages) = context[CoreExtensions.preGenerationCheck].fold(
+            Pair(true, emptyList<String>())
+        ) { acc, checker -> checker() + acc }
+        if (!preGenerationCheckResult) throw DokkaException(
+            "Pre-generation validity check failed: ${checkMessages.joinToString(",")}"
+        )
+    }
+
+    fun reportAfterRendering() {
+        context.unusedPoints.takeIf { it.isNotEmpty() }?.also {
+            context.logger.info("Unused extension points found: ${it.joinToString(", ")}")
+        }
+
+        context.logger.report()
+
+        if (context.configuration.failOnWarning && (context.logger.warningsCount > 0 || context.logger.errorsCount > 0)) {
+            throw DokkaException(
+                "Failed with warningCount=${context.logger.warningsCount} and errorCount=${context.logger.errorsCount}"
+            )
+        }
+    }
+
+    private suspend fun translateSources(sourceSet: DokkaConfiguration.DokkaSourceSet, context: DokkaContext) =
+        context[CoreExtensions.sourceToDocumentableTranslator].parallelMap { translator ->
+            when(translator){
+                is AsyncSourceToDocumentableTranslator -> translator.invokeSuspending(sourceSet, context)
+                else -> translator.invoke(sourceSet, context)
+            }
+        }
+}
\ No newline at end of file