diff options
Diffstat (limited to 'core')
6 files changed, 32 insertions, 220 deletions
diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt index 0eea416a..66e717b4 100644 --- a/core/src/main/kotlin/CoreExtensions.kt +++ b/core/src/main/kotlin/CoreExtensions.kt @@ -1,51 +1,29 @@ package org.jetbrains.dokka import org.jetbrains.dokka.generation.Generation -import org.jetbrains.dokka.generation.SingleModuleGeneration import org.jetbrains.dokka.plugability.* -import org.jetbrains.dokka.plugability.LazyEvaluated import org.jetbrains.dokka.renderers.Renderer import org.jetbrains.dokka.transformers.documentation.DocumentableMerger import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer -import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer -import org.jetbrains.dokka.transformers.pages.PageCreator import org.jetbrains.dokka.transformers.pages.PageTransformer import org.jetbrains.dokka.transformers.sources.SourceToDocumentableTranslator import org.jetbrains.dokka.validity.PreGenerationChecker import kotlin.reflect.KProperty object CoreExtensions { - private val extensionDelegates = mutableListOf<Lazy<Extension<*, *, *>>>() val preGenerationCheck by coreExtensionPoint<PreGenerationChecker>() val generation by coreExtensionPoint<Generation>() val sourceToDocumentableTranslator by coreExtensionPoint<SourceToDocumentableTranslator>() - val preMergeDocumentableTransformer by coreExtensionPoint<PreMergeDocumentableTransformer>() val documentableMerger by coreExtensionPoint<DocumentableMerger>() val documentableTransformer by coreExtensionPoint<DocumentableTransformer>() val documentableToPageTranslator by coreExtensionPoint<DocumentableToPageTranslator>() - val allModulePageCreator by coreExtensionPoint<PageCreator>() val pageTransformer by coreExtensionPoint<PageTransformer>() - val allModulePageTransformer by coreExtensionPoint<PageTransformer>() val renderer by coreExtensionPoint<Renderer>() - val singleGeneration by generation extendWith LazyEvaluated.fromRecipe(::SingleModuleGeneration) - private fun <T : Any> coreExtensionPoint() = object { operator fun provideDelegate(thisRef: CoreExtensions, property: KProperty<*>): Lazy<ExtensionPoint<T>> = lazy { ExtensionPoint<T>(thisRef::class.qualifiedName!!, property.name) } } - - private infix fun <T: Any> ExtensionPoint<T>.extendWith(action: LazyEvaluated<T>) = object { - operator fun provideDelegate(thisRef: CoreExtensions, property: KProperty<*>): Lazy<Extension<T, OrderingKind.None, OverrideKind.None>> = - lazy { Extension(this@extendWith, thisRef::class.qualifiedName!!, property.name, action) } - .also { extensionDelegates += it } - } - - internal fun installTo(context: DokkaContextConfiguration) { - extensionDelegates.forEach { - context.installExtension(it.value) - } - } }
\ No newline at end of file diff --git a/core/src/main/kotlin/generation/SingleModule.kt b/core/src/main/kotlin/generation/SingleModule.kt deleted file mode 100644 index e69de29b..00000000 --- a/core/src/main/kotlin/generation/SingleModule.kt +++ /dev/null diff --git a/core/src/main/kotlin/generation/SingleModuleGeneration.kt b/core/src/main/kotlin/generation/SingleModuleGeneration.kt deleted file mode 100644 index 2eedc561..00000000 --- a/core/src/main/kotlin/generation/SingleModuleGeneration.kt +++ /dev/null @@ -1,102 +0,0 @@ - -package org.jetbrains.dokka.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.model.DModule -import org.jetbrains.dokka.pages.RootPageNode -import org.jetbrains.dokka.plugability.DokkaContext -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[CoreExtensions.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 diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt index 1f5f6018..8703af4f 100644 --- a/core/src/main/kotlin/plugability/DokkaContext.kt +++ b/core/src/main/kotlin/plugability/DokkaContext.kt @@ -30,7 +30,6 @@ interface DokkaContext { pluginOverrides: List<DokkaPlugin> ): DokkaContext = DokkaContextConfigurationImpl(logger, configuration).apply { - CoreExtensions.installTo(this) // 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() diff --git a/core/test-api/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/core/test-api/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt deleted file mode 100644 index 0f5814f6..00000000 --- a/core/test-api/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt +++ /dev/null @@ -1,51 +0,0 @@ -package org.jetbrains.dokka.testApi.testRunner - -import org.jetbrains.dokka.CoreExtensions -import org.jetbrains.dokka.DokkaConfiguration -import org.jetbrains.dokka.DokkaGenerator -import org.jetbrains.dokka.generation.SingleModuleGeneration -import org.jetbrains.dokka.plugability.DokkaPlugin -import org.jetbrains.dokka.utilities.DokkaLogger - -internal class DokkaTestGenerator( - private val configuration: DokkaConfiguration, - private val logger: DokkaLogger, - private val testMethods: TestMethods, - private val additionalPlugins: List<DokkaPlugin> = emptyList() -) { - - fun generate() = with(testMethods) { - val dokkaGenerator = DokkaGenerator(configuration, logger) - - val context = - dokkaGenerator.initializePlugins(configuration, logger, additionalPlugins) - pluginsSetupStage(context) - - val singleModuleGeneration = context.single(CoreExtensions.generation) as SingleModuleGeneration - - val modulesFromPlatforms = singleModuleGeneration.createDocumentationModels() - documentablesCreationStage(modulesFromPlatforms) - - verificationStage { singleModuleGeneration.validityCheck(context) } - - val filteredModules = singleModuleGeneration.transformDocumentationModelBeforeMerge(modulesFromPlatforms) - documentablesFirstTransformationStep(filteredModules) - - val documentationModel = singleModuleGeneration.mergeDocumentationModels(filteredModules) - documentablesMergingStage(documentationModel) - - val transformedDocumentation = singleModuleGeneration.transformDocumentationModelAfterMerge(documentationModel) - documentablesTransformationStage(transformedDocumentation) - - val pages = singleModuleGeneration.createPages(transformedDocumentation) - pagesGenerationStage(pages) - - val transformedPages = singleModuleGeneration.transformPages(pages) - pagesTransformationStage(transformedPages) - - singleModuleGeneration.render(transformedPages) - renderingStage(transformedPages, context) - - singleModuleGeneration.reportAfterRendering() - } -} diff --git a/core/test-api/src/main/kotlin/testApi/testRunner/TestRunner.kt b/core/test-api/src/main/kotlin/testApi/testRunner/TestRunner.kt index 0b3068fc..380eb1d8 100644 --- a/core/test-api/src/main/kotlin/testApi/testRunner/TestRunner.kt +++ b/core/test-api/src/main/kotlin/testApi/testRunner/TestRunner.kt @@ -3,7 +3,6 @@ package org.jetbrains.dokka.testApi.testRunner import com.intellij.openapi.application.PathManager import org.jetbrains.dokka.* import org.jetbrains.dokka.model.DModule -import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet import org.jetbrains.dokka.pages.RootPageNode import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.plugability.DokkaPlugin @@ -21,8 +20,10 @@ import java.nio.file.Path import java.nio.file.Paths // TODO: take dokka configuration from file -abstract class AbstractCoreTest( - protected val logger: TestLogger = TestLogger(DokkaConsoleLogger) +open class AbstractTest< M: TestMethods, T : TestBuilder<M>, D: DokkaTestGenerator<M> >( + protected val testBuilder: () -> T, + protected val dokkaTestGenerator: (DokkaConfiguration, DokkaLogger, M, List<DokkaPlugin>) -> D, + protected val logger: TestLogger, ) { protected fun getTestDataDir(name: String) = File("src/test/resources/$name").takeIf { it.exists() }?.toPath() @@ -32,9 +33,9 @@ abstract class AbstractCoreTest( configuration: DokkaConfigurationImpl, cleanupOutput: Boolean = true, pluginOverrides: List<DokkaPlugin> = emptyList(), - block: TestBuilder.() -> Unit + block: T.() -> Unit ) { - val testMethods = TestBuilder().apply(block).build() + val testMethods = testBuilder().apply(block).build() val tempDir = getTempDir(cleanupOutput) if (!cleanupOutput) logger.info("Output generated under: ${tempDir.root.absolutePath}") @@ -42,7 +43,7 @@ abstract class AbstractCoreTest( configuration.copy( outputDir = tempDir.root ) - DokkaTestGenerator( + dokkaTestGenerator( newConfiguration, logger, testMethods, @@ -56,9 +57,9 @@ abstract class AbstractCoreTest( cleanupOutput: Boolean = true, pluginOverrides: List<DokkaPlugin> = emptyList(), loggerForTest: DokkaLogger = logger, - block: TestBuilder.() -> Unit + block: T.() -> Unit ) { - val testMethods = TestBuilder().apply(block).build() + val testMethods = testBuilder().apply(block).build() val testDirPath = getTempDir(cleanupOutput).root.toPath() val fileMap = query.toFileMap() fileMap.materializeFiles(testDirPath.toAbsolutePath()) @@ -82,7 +83,7 @@ abstract class AbstractCoreTest( ) } ) - DokkaTestGenerator( + dokkaTestGenerator( newConfiguration, loggerForTest, testMethods, @@ -138,31 +139,6 @@ abstract class AbstractCoreTest( }.apply { create() } } - protected class TestBuilder { - var pluginsSetupStage: (DokkaContext) -> Unit = {} - var verificationStage: (() -> Unit) -> Unit = {} - var documentablesCreationStage: (List<DModule>) -> Unit = {} - var documentablesFirstTransformationStep: (List<DModule>) -> Unit = {} - var documentablesMergingStage: (DModule) -> Unit = {} - var documentablesTransformationStage: (DModule) -> Unit = {} - var pagesGenerationStage: (RootPageNode) -> Unit = {} - var pagesTransformationStage: (RootPageNode) -> Unit = {} - var renderingStage: (RootPageNode, DokkaContext) -> Unit = { a, b -> } - - @PublishedApi - internal fun build() = TestMethods( - pluginsSetupStage, - verificationStage, - documentablesCreationStage, - documentablesFirstTransformationStep, - documentablesMergingStage, - documentablesTransformationStage, - pagesGenerationStage, - pagesTransformationStage, - renderingStage - ) - } - protected fun dokkaConfiguration(block: TestDokkaConfigurationBuilder.() -> Unit): DokkaConfigurationImpl = testApi.testRunner.dokkaConfiguration(block) @@ -193,14 +169,26 @@ abstract class AbstractCoreTest( } } -data class TestMethods( - val pluginsSetupStage: (DokkaContext) -> Unit, - val verificationStage: (() -> Unit) -> Unit, - val documentablesCreationStage: (List<DModule>) -> Unit, - val documentablesFirstTransformationStep: (List<DModule>) -> Unit, - val documentablesMergingStage: (DModule) -> Unit, - val documentablesTransformationStage: (DModule) -> Unit, - val pagesGenerationStage: (RootPageNode) -> Unit, - val pagesTransformationStage: (RootPageNode) -> Unit, - val renderingStage: (RootPageNode, DokkaContext) -> Unit +open class TestMethods( + open val pluginsSetupStage: (DokkaContext) -> Unit, + open val verificationStage: (() -> Unit) -> Unit, + open val documentablesCreationStage: (List<DModule>) -> Unit, + open val documentablesMergingStage: (DModule) -> Unit, + open val documentablesTransformationStage: (DModule) -> Unit, + open val pagesGenerationStage: (RootPageNode) -> Unit, + open val pagesTransformationStage: (RootPageNode) -> Unit, + open val renderingStage: (RootPageNode, DokkaContext) -> Unit ) + +abstract class TestBuilder<M: TestMethods> { + abstract fun build(): M +} + +abstract class DokkaTestGenerator<T: TestMethods>( + protected val configuration: DokkaConfiguration, + protected val logger: DokkaLogger, + protected val testMethods: T, + protected val additionalPlugins: List<DokkaPlugin> = emptyList() +) { + abstract fun generate() +}
\ No newline at end of file |