From 3f2a790190da4f40ea6d8a976aa1929b2a1b002b Mon Sep 17 00:00:00 2001 From: Błażej Kardyś Date: Tue, 5 May 2020 17:45:12 +0200 Subject: Changing approach from platform-driven to source-set-driven --- plugins/base/src/main/kotlin/DokkaBase.kt | 6 +- .../src/main/kotlin/renderers/DefaultRenderer.kt | 21 +- .../src/main/kotlin/renderers/html/HtmlRenderer.kt | 58 ++--- .../main/kotlin/renderers/html/NavigationPage.kt | 4 +- .../resolvers/local/DefaultLocationProvider.kt | 9 +- .../kotlin/resolvers/local/LocationProvider.kt | 4 +- .../kotlin/signatures/KotlinSignatureProvider.kt | 35 ++- .../documentables/ActualTypealiasAdder.kt | 8 +- .../documentables/DefaultDocumentableMerger.kt | 233 ++++++++----------- .../documentables/DocumentableVisibilityFilter.kt | 55 +++-- .../InheritorsExtractorTransformer.kt | 23 +- .../ModuleAndPackageDocumentationTransformer.kt | 42 ++-- .../pages/comments/CommentsToContentConverter.kt | 3 +- .../pages/comments/DocTagToContentConverter.kt | 33 +-- .../merger/SameMethodNamePageMergerStrategy.kt | 2 +- .../pages/samples/SamplesTransformer.kt | 25 +- .../pages/sourcelinks/SourceLinksTransformer.kt | 23 +- .../DefaultDescriptorToDocumentableTranslator.kt | 252 ++++++++++----------- .../documentables/DefaultPageCreator.kt | 111 +++++---- .../documentables/PageContentBuilder.kt | 98 ++++---- .../psi/DefaultPsiToDocumentableTranslator.kt | 57 +++-- 21 files changed, 528 insertions(+), 574 deletions(-) (limited to 'plugins/base/src/main/kotlin') diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt index 2da3fbd4..ab7d089d 100644 --- a/plugins/base/src/main/kotlin/DokkaBase.kt +++ b/plugins/base/src/main/kotlin/DokkaBase.kt @@ -54,15 +54,15 @@ class DokkaBase : DokkaPlugin() { } val preMergeDocumentableTransformer by extending(isFallback = true) { - CoreExtensions.preMergeDocumentableTransformer with DocumentableVisibilityFilter + CoreExtensions.preMergeDocumentableTransformer providing ::DocumentableVisibilityFilter } val actualTypealiasAdder by extending { - CoreExtensions.preMergeDocumentableTransformer with ActualTypealiasAdder() + CoreExtensions.preMergeDocumentableTransformer providing ::ActualTypealiasAdder } val modulesAndPackagesDocumentation by extending(isFallback = true) { - CoreExtensions.preMergeDocumentableTransformer with ModuleAndPackageDocumentationTransformer + CoreExtensions.preMergeDocumentableTransformer providing ::ModuleAndPackageDocumentationTransformer } val kotlinSignatureProvider by extending(isFallback = true) { diff --git a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt index 925767ce..1340529c 100644 --- a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt +++ b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt @@ -3,6 +3,7 @@ package org.jetbrains.dokka.base.renderers import kotlinx.coroutines.* import org.jetbrains.dokka.base.DokkaBase import org.jetbrains.dokka.base.resolvers.local.LocationProvider +import org.jetbrains.dokka.model.SourceSetData import org.jetbrains.dokka.pages.* import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.plugability.plugin @@ -26,7 +27,7 @@ abstract class DefaultRenderer( abstract fun T.buildList( node: ContentList, pageContext: ContentPage, - platformRestriction: PlatformData? = null + platformRestriction: SourceSetData? = null ) abstract fun T.buildNewLine() @@ -34,7 +35,7 @@ abstract class DefaultRenderer( abstract fun T.buildTable( node: ContentTable, pageContext: ContentPage, - platformRestriction: PlatformData? = null + platformRestriction: SourceSetData? = null ) abstract fun T.buildText(textNode: ContentText) @@ -49,7 +50,7 @@ abstract class DefaultRenderer( open fun T.buildGroup( node: ContentGroup, pageContext: ContentPage, - platformRestriction: PlatformData? = null + platformRestriction: SourceSetData? = null ) = wrapGroup(node, pageContext) { node.children.forEach { it.build(this, pageContext, platformRestriction) } } @@ -59,7 +60,7 @@ abstract class DefaultRenderer( open fun T.buildLinkText( nodes: List, pageContext: ContentPage, - platformRestriction: PlatformData? = null + platformRestriction: SourceSetData? = null ) { nodes.forEach { it.build(this, pageContext, platformRestriction) } } @@ -71,7 +72,7 @@ abstract class DefaultRenderer( open fun T.buildHeader( node: ContentHeader, pageContext: ContentPage, - platformRestriction: PlatformData? = null + platformRestriction: SourceSetData? = null ) { buildHeader(node.level) { node.children.forEach { it.build(this, pageContext, platformRestriction) } } } @@ -79,22 +80,22 @@ abstract class DefaultRenderer( open fun ContentNode.build( builder: T, pageContext: ContentPage, - platformRestriction: PlatformData? = null + platformRestriction: SourceSetData? = null ) = builder.buildContentNode(this, pageContext, platformRestriction) open fun T.buildContentNode( node: ContentNode, pageContext: ContentPage, - platformRestriction: PlatformData? = null + platformRestriction: SourceSetData? = null ) { - if (platformRestriction == null || platformRestriction in node.platforms) { + if (platformRestriction == null || platformRestriction in node.sourceSets) { when (node) { is ContentText -> buildText(node) is ContentHeader -> buildHeader(node, pageContext, platformRestriction) is ContentCode -> buildCode(node.children, node.language, pageContext) is ContentDRILink -> - buildLink(locationProvider.resolve(node.address, node.platforms.toList(), pageContext)) { + buildLink(locationProvider.resolve(node.address, node.sourceSets.toList(), pageContext)) { buildLinkText(node.children, pageContext, platformRestriction) } is ContentResolvedLink -> buildLink(node.address) { @@ -154,4 +155,4 @@ abstract class DefaultRenderer( } } -fun ContentPage.platforms() = this.content.platforms.toList() \ No newline at end of file +fun ContentPage.platforms() = this.content.sourceSets.toList() \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt index c061cabf..caabcda7 100644 --- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt +++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt @@ -7,6 +7,7 @@ import org.jetbrains.dokka.base.DokkaBase import org.jetbrains.dokka.base.renderers.DefaultRenderer import org.jetbrains.dokka.links.DRI import org.jetbrains.dokka.model.DFunction +import org.jetbrains.dokka.model.SourceSetData import org.jetbrains.dokka.pages.* import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.plugability.plugin @@ -42,10 +43,10 @@ open class HtmlRenderer( override fun FlowContent.buildPlatformDependent(content: PlatformHintedContent, pageContext: ContentPage) { div("platform-hinted") { attributes["data-platform-hinted"] = "data-platform-hinted" - val contents = content.platforms.mapIndexed { index, platform -> + val contents = content.sourceSets.mapIndexed { index, platform -> platform to createHTML(prettyPrint = false).div(classes = "content") { if (index == 0) attributes["data-active"] = "" - attributes["data-togglable"] = platform.targets.joinToString("-") + attributes["data-togglable"] = platform.sourceSetName buildContentNode(content.inner, pageContext, platform) } } @@ -56,8 +57,8 @@ open class HtmlRenderer( contents.forEachIndexed { index, pair -> button(classes = "platform-bookmark") { if (index == 0) attributes["data-active"] = "" - attributes["data-toggle"] = pair.first.targets.joinToString("-") - text(pair.first.targets.joinToString(", ")); + attributes["data-toggle"] = pair.first.sourceSetName + text(pair.first.sourceSetName) } } } @@ -71,27 +72,27 @@ open class HtmlRenderer( override fun FlowContent.buildList( node: ContentList, pageContext: ContentPage, - platformRestriction: PlatformData? - ) = if (node.ordered) ol { buildListItems(node.children, pageContext, platformRestriction) } - else ul { buildListItems(node.children, pageContext, platformRestriction) } + sourceSetRestriction: SourceSetData? + ) = if (node.ordered) ol { buildListItems(node.children, pageContext, sourceSetRestriction) } + else ul { buildListItems(node.children, pageContext, sourceSetRestriction) } open fun OL.buildListItems( items: List, pageContext: ContentPage, - platformRestriction: PlatformData? = null + sourceSetRestriction: SourceSetData? = null ) { items.forEach { if (it is ContentList) buildList(it, pageContext) else - li { it.build(this, pageContext, platformRestriction) } + li { it.build(this, pageContext, sourceSetRestriction) } } } open fun UL.buildListItems( items: List, pageContext: ContentPage, - platformRestriction: PlatformData? = null + sourceSetRestriction: SourceSetData? = null ) { items.forEach { if (it is ContentList) @@ -118,64 +119,63 @@ open class HtmlRenderer( private fun FlowContent.buildRow( node: ContentGroup, pageContext: ContentPage, - platformRestriction: PlatformData? + sourceSetRestriction: SourceSetData? ) { node.children .filter { - platformRestriction == null || platformRestriction in it.platforms + sourceSetRestriction == null || sourceSetRestriction in it.sourceSets } .takeIf { it.isNotEmpty() } ?.let { div(classes = "table-row") { it.filter { it.dci.kind != ContentKind.Symbol }.takeIf { it.isNotEmpty() }?.let { div("main-subrow ${node.style.joinToString { it.toString().decapitalize() }}") { - it.filter { platformRestriction == null || platformRestriction in it.platforms } + it.filter { sourceSetRestriction == null || sourceSetRestriction in it.sourceSets } .forEach { when(it.dci.kind){ - ContentKind.PlatformDependantHint -> { + ContentKind.SourceSetDependantHint -> { div("platform-dependant-row keyValue"){ div() div("title"){ - it.build(this, pageContext, platformRestriction) + it.build(this, pageContext, sourceSetRestriction) } } } ContentKind.Main -> { div("title-row"){ - it.build(this, pageContext, platformRestriction) + it.build(this, pageContext, sourceSetRestriction) div() - if (ContentKind.shouldBePlatformTagged(node.dci.kind) && node.platforms.size == 1) { + if (ContentKind.shouldBePlatformTagged(node.dci.kind) && node.sourceSets.size == 1) { createPlatformTags(node) } else { div() } } } - else -> div { it.build(this, pageContext, platformRestriction) } + else -> div { it.build(this, pageContext, sourceSetRestriction) } } } } } it.filter { it.dci.kind == ContentKind.Symbol }.takeIf { it.isNotEmpty() }?.let { div("signature-subrow") { - div("signatures"){ + div("signatures") { it.forEach { - it.build(this, pageContext, platformRestriction) + it.build(this, pageContext, sourceSetRestriction) } } } } } - } + } } - private fun FlowContent.createPlatformTags( node: ContentNode ) { + private fun FlowContent.createPlatformTags(node: ContentNode) { div("platform-tags") { - node.platforms.forEach { + node.sourceSets.forEach { div("platform-tag") { - val targets = it.targets.joinToString(", ") - if( targets.equals("common", ignoreCase = true) ) classes = classes + "common" - text(it.targets.joinToString(", ")) + if (it.sourceSetName.equals("common", ignoreCase = true)) classes = classes + "common" + text(it.sourceSetName) } } } @@ -184,11 +184,11 @@ open class HtmlRenderer( override fun FlowContent.buildTable( node: ContentTable, pageContext: ContentPage, - platformRestriction: PlatformData? + sourceSetRestriction: SourceSetData? ) { div(classes = "table") { node.children.forEach { - buildRow(it, pageContext, platformRestriction) + buildRow(it, pageContext, sourceSetRestriction) } } } @@ -221,7 +221,7 @@ open class HtmlRenderer( fun FlowContent.buildLink( to: DRI, - platforms: List, + platforms: List, from: PageNode? = null, block: FlowContent.() -> Unit ) = buildLink(locationProvider.resolve(to, platforms, from), block) diff --git a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt index 4b90cc8a..4048c11e 100644 --- a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt +++ b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt @@ -3,8 +3,8 @@ package org.jetbrains.dokka.base.renderers.html import kotlinx.html.* import kotlinx.html.stream.createHTML import org.jetbrains.dokka.links.DRI +import org.jetbrains.dokka.model.SourceSetData import org.jetbrains.dokka.pages.PageNode -import org.jetbrains.dokka.pages.PlatformData import org.jetbrains.dokka.pages.RendererSpecificPage import org.jetbrains.dokka.pages.RenderingStrategy @@ -41,7 +41,7 @@ class NavigationPage(val root: NavigationNode) : RendererSpecificPage { class NavigationNode( val name: String, val dri: DRI, - val platforms: List, + val platforms: List, val children: List ) diff --git a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt index 29c4a425..322f4927 100644 --- a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt +++ b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt @@ -4,6 +4,8 @@ import org.jetbrains.dokka.DokkaConfiguration import org.jetbrains.dokka.base.DokkaBase import org.jetbrains.dokka.base.resolvers.external.ExternalLocationProvider import org.jetbrains.dokka.links.DRI +import org.jetbrains.dokka.model.SourceSetData +import org.jetbrains.dokka.model.sourceSet import org.jetbrains.dokka.pages.* import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.plugability.plugin @@ -46,15 +48,14 @@ open class DefaultLocationProvider( override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String = pathTo(node, context) + if (!skipExtension) extension else "" - override fun resolve(dri: DRI, platforms: List, context: PageNode?): String = + override fun resolve(dri: DRI, sourceSets: List, context: PageNode?): String = pagesIndex[dri]?.let { resolve(it, context) } ?: // Not found in PageGraph, that means it's an external link getLocation(dri, this.dokkaContext.configuration.passesConfigurations .filter { passConfig -> - platforms.toSet() - .contains(PlatformData(passConfig.moduleName, passConfig.analysisPlatform, passConfig.targets)) - } // TODO: change targets to something better? + sourceSets.toSet().contains(dokkaContext.sourceSet(passConfig)) + } .groupBy({ it.jdkVersion }, { it.externalDocumentationLinks }) .map { it.key to it.value.flatten().distinct() }.toMap() ) diff --git a/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt index 0814cb3e..c6c48d63 100644 --- a/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt +++ b/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt @@ -1,12 +1,12 @@ package org.jetbrains.dokka.base.resolvers.local import org.jetbrains.dokka.links.DRI +import org.jetbrains.dokka.model.SourceSetData import org.jetbrains.dokka.pages.PageNode -import org.jetbrains.dokka.pages.PlatformData import org.jetbrains.dokka.pages.RootPageNode interface LocationProvider { - fun resolve(dri: DRI, platforms: List, context: PageNode? = null): String + fun resolve(dri: DRI, sourceSets: List, context: PageNode? = null): String fun resolve(node: PageNode, context: PageNode? = null, skipExtension: Boolean = false): String fun resolveRoot(node: PageNode): String fun ancestors(node: PageNode): List diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt index 313973bf..241103bf 100644 --- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt +++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt @@ -10,7 +10,6 @@ import org.jetbrains.dokka.model.* import org.jetbrains.dokka.model.properties.WithExtraProperties import org.jetbrains.dokka.pages.ContentKind import org.jetbrains.dokka.pages.ContentNode -import org.jetbrains.dokka.pages.PlatformData import org.jetbrains.dokka.pages.TextStyle import org.jetbrains.dokka.utilities.DokkaLogger @@ -35,7 +34,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog link(e.name, e.dri) } - private fun actualTypealiasedSignature(dri: DRI, name: String, aliasedTypes: PlatformDependent) = + private fun actualTypealiasedSignature(dri: DRI, name: String, aliasedTypes: SourceSetDependent) = aliasedTypes.entries.groupBy({ it.value }, { it.key }).map { (bound, platforms) -> contentBuilder.contentFor(dri, platforms.toSet(), ContentKind.Symbol, setOf(TextStyle.Monospace)) { text("actual typealias ") @@ -49,17 +48,17 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog (c as? WithExtraProperties)?.let { c.extra[ActualTypealias]?.let { contentBuilder.contentFor(c) { - +regularSignature(c, platformData = c.platformData.toSet() - it.underlyingType.keys) + +regularSignature(c, sourceSets = c.sourceSets.toSet() - it.underlyingType.keys) +actualTypealiasedSignature(c.dri, c.name.orEmpty(), it.underlyingType) } } ?: regularSignature(c) } ?: regularSignature(c) - private fun regularSignature(c: DClasslike, platformData: Set = c.platformData.toSet()) = - contentBuilder.contentFor(c, ContentKind.Symbol, setOf(TextStyle.Monospace), platformData = platformData) { - platformText(c.visibility, platformData) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " } + private fun regularSignature(c: DClasslike, sourceSets: Set = c.sourceSets.toSet()) = + contentBuilder.contentFor(c, ContentKind.Symbol, setOf(TextStyle.Monospace), sourceSets = sourceSets) { + platformText(c.visibility, sourceSets) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " } if (c is DClass) { - platformText(c.modifier, platformData) { + platformText(c.modifier, sourceSets) { if (c.extra[AdditionalModifiers]?.content?.contains(ExtraModifiers.DATA) == true && it.name == "final") "data " else it.name + " " } @@ -74,23 +73,23 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog link(c.name!!, c.dri) if (c is DClass) { val pConstructor = c.constructors.singleOrNull { it.extra[PrimaryConstructorExtra] != null } - list(pConstructor?.parameters.orEmpty(), "(", ")", ",", pConstructor?.platformData.orEmpty().toSet()) { + list(pConstructor?.parameters.orEmpty(), "(", ")", ",", pConstructor?.sourceSets.orEmpty().toSet()) { text(it.name ?: "", styles = mainStyles.plus(TextStyle.Bold).plus(TextStyle.Indented)) text(": ") signatureForProjection(it.type) } } if (c is WithSupertypes) { - c.supertypes.filter { it.key in platformData }.map { (p, dris) -> - list(dris, prefix = " : ", platformData = setOf(p)) { - link(it.sureClassNames, it, platformData = setOf(p)) + c.supertypes.filter { it.key in sourceSets }.map { (p, dris) -> + list(dris, prefix = " : ", sourceSets = setOf(p)) { + link(it.sureClassNames, it, sourceSets = setOf(p)) } } } } - private fun propertySignature(p: DProperty, platformData: Set = p.platformData.toSet()) = - contentBuilder.contentFor(p, ContentKind.Symbol, setOf(TextStyle.Monospace), platformData = platformData) { + private fun propertySignature(p: DProperty, sourceSets: Set = p.sourceSets.toSet()) = + contentBuilder.contentFor(p, ContentKind.Symbol, setOf(TextStyle.Monospace), sourceSets = sourceSets) { platformText(p.visibility) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " } platformText(p.modifier){ it.name + " "} p.setter?.let { text("var ") } ?: text("val ") @@ -106,8 +105,8 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog signatureForProjection(p.type) } - private fun functionSignature(f: DFunction, platformData: Set = f.platformData.toSet()) = - contentBuilder.contentFor(f, ContentKind.Symbol, setOf(TextStyle.Monospace), platformData = platformData) { + private fun functionSignature(f: DFunction, sourceSets: Set = f.sourceSets.toSet()) = + contentBuilder.contentFor(f, ContentKind.Symbol, setOf(TextStyle.Monospace), sourceSets = sourceSets) { platformText(f.visibility) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " } platformText(f.modifier) { it.name + " " } text("fun ") @@ -147,7 +146,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog t, ContentKind.Symbol, setOf(TextStyle.Monospace), - platformData = platforms.toSet() + sourceSets = platforms.toSet() ) { platformText(t.visibility) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " } text("typealias ") @@ -196,8 +195,8 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog is PrimitiveJavaType -> signatureForProjection(p.translateToKotlin()) } - private fun funType(dri: DRI, platformData: Set, type: TypeConstructor) = - contentBuilder.contentFor(dri, platformData, ContentKind.Symbol, setOf(TextStyle.Monospace)) { + private fun funType(dri: DRI, sourceSets: Set, type: TypeConstructor) = + contentBuilder.contentFor(dri, sourceSets, ContentKind.Symbol, setOf(TextStyle.Monospace)) { if (type.extension) { signatureForProjection(type.projections.first()) text(".") diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt index 35f27a94..cab4a9d2 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt @@ -6,8 +6,8 @@ import org.jetbrains.dokka.model.properties.WithExtraProperties import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer -class ActualTypealiasAdder : PreMergeDocumentableTransformer { - override fun invoke(modules: List, context: DokkaContext) = modules.map { it.mergeTypealiases() } +class ActualTypealiasAdder(val context: DokkaContext) : PreMergeDocumentableTransformer { + override fun invoke(modules: List) = modules.map { it.mergeTypealiases() } private fun DModule.mergeTypealiases(): DModule = copy(packages = packages.map { pkg -> if (pkg.typealiases.isEmpty()) { @@ -64,11 +64,11 @@ class ActualTypealiasAdder : PreMergeDocumentableTransformer { typealiases: Map ): List where T : DClasslike, T : WithExtraProperties, T : WithExpectActual = elements.map { element -> - if (element.sources.expect != null) { + if (element.expectPresentInSet != null) { typealiases[element.dri]?.let { ta -> element.withNewExtras( element.extra + ActualTypealias( - PlatformDependent.from(ta.platformData.single(), ta.underlyingType.values.single()) + mapOf(ta.sourceSets.single() to ta.underlyingType.values.single()) ) ) } ?: element diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt index f871cdec..862f9240 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt @@ -2,7 +2,6 @@ package org.jetbrains.dokka.base.transformers.documentables import org.jetbrains.dokka.model.* import org.jetbrains.dokka.model.properties.mergeExtras -import org.jetbrains.dokka.pages.PlatformData import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.transformers.documentation.DocumentableMerger import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult @@ -24,8 +23,9 @@ internal object DefaultDocumentableMerger : DocumentableMerger { list.flatMap { it.packages }, DPackage::mergeWith ), - documentation = list.platformDependentFor { documentation }, - platformData = list.flatMap { it.platformData }.distinct() + documentation = list.map { it.documentation }.flatMap { it.entries }.associate { (k,v) -> k to v }, + expectPresentInSet = list.firstNotNullResult { it.expectPresentInSet }, + sourceSets = list.flatMap { it.sourceSets } ).mergeExtras(left, right) } } @@ -36,115 +36,51 @@ private fun merge(elements: List, reducer: (T, T) -> T): L .reduce { _, left, right -> reducer(left, right) } .values.toList() -private fun Iterable.platformDependentFor( - selector: D.() -> PlatformDependent -): PlatformDependent { - val actuals = map { it.selector().map } - .flatMap { it.entries } - .associate { (k, v) -> k to v } - - val expected = firstNotNullResult { it.selector().expect } - - return PlatformDependent(actuals, expected) -} - -private fun PlatformDependent.mergeWith(other: PlatformDependent) = PlatformDependent( - map = this + other, - expect = expect ?: other.expect -) - private fun mergeExpectActual( elements: List, - reducer: (T, T) -> T, - platformSetter: T.(List) -> T + reducer: (T, T) -> T ): List where T : Documentable, T : WithExpectActual { - fun findExpect(actual: T, expects: List): Expect = - expects.find { it.platformData.flatMap { it.targets }.containsAll(actual.platformData.flatMap { it.targets }) } - .let { Expect.from(it) } - - fun reduceExpectActual(entry: Map.Entry, List>): List = when (val expect = entry.key) { - Expect.NotFound -> entry.value - is Expect.Found -> entry.value.plus(expect.expect).reduce(reducer).let(::listOf) - } - - fun analyzeExpectActual(sameDriElements: List): List { - val pathGrouped: Collection = mutableMapOf, T>().apply { - sameDriElements.forEach { documentable -> - val paths = documentable.sources.allValues.map { it.path }.toSet() - val key = keys.find { it.containsAll(paths) } - if (key == null) { - put(paths, documentable) - } else { - computeIfPresent(key) { _, old -> reducer(old, documentable) } - } - } - }.values - val (expect, actual) = pathGrouped.partition { it.sources.expect != null } - val mergedExpect = expect.groupBy { it.sources.expect?.path }.values.map { e -> - e.first().platformSetter(e.flatMap { it.platformData }.distinct()) - } - val groupExpectActual = actual.groupBy { findExpect(it, mergedExpect) } - val pathsToExpects: Set = - groupExpectActual.keys.filterIsInstance>() - .mapNotNull { it.expect.sources.expect?.path }.toSet() + fun analyzeExpectActual(sameDriElements: List) = sameDriElements.reduce(reducer) - return groupExpectActual.flatMap { reduceExpectActual(it) } + expect.filterNot { it.sources.expect?.path in pathsToExpects } - } - - return elements.groupBy { it.dri }.values.flatMap(::analyzeExpectActual) -} - -private sealed class Expect { - object NotFound : Expect() - data class Found(val expect: T) : Expect() - - companion object { - fun from(t: T?) = t?.let(::Found) ?: NotFound - } + return elements.groupBy { it.dri }.values.map(::analyzeExpectActual) } fun DPackage.mergeWith(other: DPackage): DPackage = copy( - functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) }, - properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) }, - classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData), - documentation = documentation.mergeWith(other.documentation), + functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith), + properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith), + classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith), + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, typealiases = merge(typealiases + other.typealiases, DTypeAlias::mergeWith), - platformData = (platformData + other.platformData).distinct() + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DFunction.mergeWith(other: DFunction): DFunction = copy( parameters = merge(this.parameters + other.parameters, DParameter::mergeWith), receiver = receiver?.let { r -> other.receiver?.let { r.mergeWith(it) } ?: r } ?: other.receiver, - documentation = documentation.mergeWith(other.documentation), - sources = sources.mergeWith(other.sources), - visibility = visibility.mergeWith(other.visibility), - modifier = modifier.mergeWith(other.modifier), - platformData = (platformData + other.platformData).distinct(), + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sources = sources+ other.sources, + visibility = visibility + other.visibility, + modifier = modifier + other.modifier, + sourceSets = sourceSets + other.sourceSets, generics = merge(generics + other.generics, DTypeParameter::mergeWith) ).mergeExtras(this, other) fun DProperty.mergeWith(other: DProperty): DProperty = copy( receiver = receiver?.let { r -> other.receiver?.let { r.mergeWith(it) } ?: r } ?: other.receiver, - documentation = documentation.mergeWith(other.documentation), - sources = sources.mergeWith(other.sources), - visibility = visibility.mergeWith(other.visibility), - modifier = modifier.mergeWith(other.modifier), - platformData = (platformData + other.platformData).distinct(), + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sources = sources+ other.sources, + visibility = visibility + other.visibility, + modifier = modifier + other.modifier, + sourceSets = sourceSets + other.sourceSets, getter = getter?.let { g -> other.getter?.let { g.mergeWith(it) } ?: g } ?: other.getter, setter = setter?.let { s -> other.setter?.let { s.mergeWith(it) } ?: s } ?: other.setter, generics = merge(generics + other.generics, DTypeParameter::mergeWith) ).mergeExtras(this, other) -fun DClasslike.setPlatformData(platformData: List): DClasslike = when (this) { - is DClass -> copy(platformData = platformData) - is DEnum -> copy(platformData = platformData) - is DInterface -> copy(platformData = platformData) - is DObject -> copy(platformData = platformData) - is DAnnotation -> copy(platformData = platformData) - else -> throw IllegalStateException("${this::class.qualifiedName} ${this.name} cannot have platform set") -} - fun DClasslike.mergeWith(other: DClasslike): DClasslike = when { this is DClass && other is DClass -> mergeWith(other) this is DEnum && other is DEnum -> mergeWith(other) @@ -158,18 +94,19 @@ fun DClass.mergeWith(other: DClass): DClass = copy( constructors = mergeExpectActual( constructors + other.constructors, DFunction::mergeWith - ) { copy(platformData = it) }, - functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) }, - properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) }, - classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData), + ), + functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith), + properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith), + classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith), companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion, generics = merge(generics + other.generics, DTypeParameter::mergeWith), - modifier = modifier.mergeWith(other.modifier), - supertypes = supertypes.mergeWith(other.supertypes), - documentation = documentation.mergeWith(other.documentation), - sources = sources.mergeWith(other.sources), - visibility = visibility.mergeWith(other.visibility), - platformData = (platformData + other.platformData).distinct() + modifier = modifier + other.modifier, + supertypes = supertypes + other.supertypes, + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sources = sources+ other.sources, + visibility = visibility + other.visibility, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DEnum.mergeWith(other: DEnum): DEnum = copy( @@ -177,78 +114,86 @@ fun DEnum.mergeWith(other: DEnum): DEnum = copy( constructors = mergeExpectActual( constructors + other.constructors, DFunction::mergeWith - ) { copy(platformData = it) }, - functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) }, - properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) }, - classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData), + ), + functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith), + properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith), + classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith), companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion, - supertypes = supertypes.mergeWith(other.supertypes), - documentation = documentation.mergeWith(other.documentation), - sources = sources.mergeWith(other.sources), - visibility = visibility.mergeWith(other.visibility), - platformData = (platformData + other.platformData).distinct() + supertypes = supertypes + other.supertypes, + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sources = sources+ other.sources, + visibility = visibility + other.visibility, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DEnumEntry.mergeWith(other: DEnumEntry): DEnumEntry = copy( - functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) }, - properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) }, - classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData), - documentation = documentation.mergeWith(other.documentation), - platformData = (platformData + other.platformData).distinct() + functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith), + properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith), + classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith), + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DObject.mergeWith(other: DObject): DObject = copy( - functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) }, - properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) }, - classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData), - supertypes = supertypes.mergeWith(other.supertypes), - documentation = documentation.mergeWith(other.documentation), - sources = sources.mergeWith(other.sources), - visibility = visibility.mergeWith(other.visibility), - platformData = (platformData + other.platformData).distinct() + functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith), + properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith), + classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith), + supertypes = supertypes + other.supertypes, + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sources = sources+ other.sources, + visibility = visibility + other.visibility, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DInterface.mergeWith(other: DInterface): DInterface = copy( - functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) }, - properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) }, - classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData), + functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith), + properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith), + classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith), companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion, generics = merge(generics + other.generics, DTypeParameter::mergeWith), - supertypes = supertypes.mergeWith(other.supertypes), - documentation = documentation.mergeWith(other.documentation), - sources = sources.mergeWith(other.sources), - visibility = visibility.mergeWith(other.visibility), - platformData = (platformData + other.platformData).distinct() + supertypes = supertypes + other.supertypes, + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sources = sources+ other.sources, + visibility = visibility + other.visibility, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DAnnotation.mergeWith(other: DAnnotation): DAnnotation = copy( constructors = mergeExpectActual( constructors + other.constructors, DFunction::mergeWith - ) { copy(platformData = it) }, - functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) }, - properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) }, - classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData), + ), + functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith), + properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith), + classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith), companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion, - documentation = documentation.mergeWith(other.documentation), - sources = sources.mergeWith(other.sources), - visibility = visibility.mergeWith(other.visibility), - platformData = (platformData + other.platformData).distinct() + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sources = sources+ other.sources, + visibility = visibility + other.visibility, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DParameter.mergeWith(other: DParameter): DParameter = copy( - documentation = documentation.mergeWith(other.documentation), - platformData = (platformData + other.platformData).distinct() + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DTypeParameter.mergeWith(other: DTypeParameter): DTypeParameter = copy( - documentation = documentation.mergeWith(other.documentation), - platformData = (platformData + other.platformData).distinct() + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) fun DTypeAlias.mergeWith(other: DTypeAlias): DTypeAlias = copy( - documentation = documentation.mergeWith(other.documentation), - underlyingType = underlyingType.mergeWith(other.underlyingType), - visibility = visibility.mergeWith(other.visibility), - platformData = (platformData + other.platformData).distinct() + documentation = documentation + other.documentation, + expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet, + underlyingType = underlyingType + other.underlyingType, + visibility = visibility + other.visibility, + sourceSets = sourceSets + other.sourceSets ).mergeExtras(this, other) \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt index c261d2dc..6fdce3a8 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt @@ -5,15 +5,14 @@ import org.jetbrains.dokka.model.* import org.jetbrains.dokka.model.DAnnotation import org.jetbrains.dokka.model.DEnum import org.jetbrains.dokka.model.DFunction -import org.jetbrains.dokka.pages.PlatformData import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer -internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { +internal class DocumentableVisibilityFilter(val context: DokkaContext) : PreMergeDocumentableTransformer { - override fun invoke(modules: List, context: DokkaContext): List = modules.map { original -> + override fun invoke(modules: List): List = modules.map { original -> val packageOptions = - context.configuration.passesConfigurations.first { original.platformData.contains(it.platformData) } + context.configuration.passesConfigurations.first { original.sourceSets.contains(context.sourceSet(it)) } .perPackageOptions DocumentableFilter(packageOptions).processModule(original) @@ -36,7 +35,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { original.name, packages = packages, documentation = original.documentation, - platformData = original.platformData, + sourceSets = original.sourceSets, extra = original.extra ) } @@ -69,7 +68,8 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { classlikes, it.typealiases, it.documentation, - it.platformData, + it.expectPresentInSet, + it.sourceSets, it.extra ) } @@ -78,26 +78,25 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { return Pair(packagesListChanged, filteredPackages) } - private fun alwaysTrue(a: T, p: PlatformData) = true - private fun alwaysFalse(a: T, p: PlatformData) = false + private fun alwaysTrue(a: T, p: SourceSetData) = true + private fun alwaysFalse(a: T, p: SourceSetData) = false - private fun WithVisibility.visibilityForPlatform(data: PlatformData): Visibility? = - visibility[data] ?: visibility.expect + private fun WithVisibility.visibilityForPlatform(data: SourceSetData): Visibility? = visibility[data] private fun T.filterPlatforms( - additionalCondition: (T, PlatformData) -> Boolean = ::alwaysTrue, - alternativeCondition: (T, PlatformData) -> Boolean = ::alwaysFalse + additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue, + alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse ) where T : Documentable, T : WithVisibility = - platformData.filter { d -> + sourceSets.filter { d -> visibilityForPlatform(d)?.isAllowedInPackage(dri.packageName) == true && additionalCondition(this, d) || alternativeCondition(this, d) } private fun List.transform( - additionalCondition: (T, PlatformData) -> Boolean = ::alwaysTrue, - alternativeCondition: (T, PlatformData) -> Boolean = ::alwaysFalse, - recreate: (T, List) -> T + additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue, + alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse, + recreate: (T, List) -> T ): Pair> where T : Documentable, T : WithVisibility { var changed = false val values = mapNotNull { t -> @@ -119,7 +118,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { private fun filterFunctions( functions: List, - additionalCondition: (DFunction, PlatformData) -> Boolean = ::alwaysTrue + additionalCondition: (DFunction, SourceSetData) -> Boolean = ::alwaysTrue ) = functions.transform(additionalCondition) { original, filteredPlatforms -> with(original) { @@ -129,6 +128,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { isConstructor, parameters, documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), sources.filtered(filteredPlatforms), visibility.filtered(filteredPlatforms), type, @@ -141,13 +141,13 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { } } - private fun hasVisibleAccessorsForPlatform(property: DProperty, data: PlatformData) = + private fun hasVisibleAccessorsForPlatform(property: DProperty, data: SourceSetData) = property.getter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true || property.setter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true private fun filterProperties( properties: List, - additionalCondition: (DProperty, PlatformData) -> Boolean = ::alwaysTrue + additionalCondition: (DProperty, SourceSetData) -> Boolean = ::alwaysTrue ): Pair> = properties.transform(additionalCondition, ::hasVisibleAccessorsForPlatform) { original, filteredPlatforms -> with(original) { @@ -155,6 +155,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { dri, name, documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), sources.filtered(filteredPlatforms), visibility.filtered(filteredPlatforms), type, @@ -169,16 +170,17 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { } } - private fun filterEnumEntries(entries: List, filteredPlatforms: List) = + private fun filterEnumEntries(entries: List, filteredPlatforms: List) = entries.mapNotNull { entry -> - if (filteredPlatforms.containsAll(entry.platformData)) entry + if (filteredPlatforms.containsAll(entry.sourceSets)) entry else { - val intersection = filteredPlatforms.intersect(entry.platformData).toList() + val intersection = filteredPlatforms.intersect(entry.sourceSets).toList() if (intersection.isEmpty()) null else DEnumEntry( entry.dri, entry.name, entry.documentation.filtered(intersection), + entry.expectPresentInSet.filtered(filteredPlatforms), filterFunctions(entry.functions) { _, data -> data in intersection }.second, filterProperties(entry.properties) { _, data -> data in intersection }.second, filterClasslikes(entry.classlikes) { _, data -> data in intersection }.second, @@ -190,7 +192,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { private fun filterClasslikes( classlikeList: List, - additionalCondition: (DClasslike, PlatformData) -> Boolean = ::alwaysTrue + additionalCondition: (DClasslike, SourceSetData) -> Boolean = ::alwaysTrue ): Pair> { var classlikesListChanged = false val filteredClasslikes: List = classlikeList.mapNotNull { @@ -200,7 +202,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { classlikesListChanged = true null } else { - var modified = platformData.size != filteredPlatforms.size + var modified = sourceSets.size != filteredPlatforms.size val functions = filterFunctions(functions) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> modified = modified || listModified @@ -246,6 +248,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { generics, supertypes.filtered(filteredPlatforms), documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), modifier, filteredPlatforms, extra @@ -254,6 +257,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { name, dri, documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), sources.filtered(filteredPlatforms), functions, properties, @@ -269,6 +273,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { name, enumEntries, documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), sources.filtered(filteredPlatforms), functions, properties, @@ -284,6 +289,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { dri, name, documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), sources.filtered(filteredPlatforms), functions, properties, @@ -299,6 +305,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer { name, dri, documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), sources.filtered(filteredPlatforms), functions, properties, diff --git a/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt index 9cc09d89..15ffc08a 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt @@ -4,7 +4,6 @@ import org.jetbrains.dokka.links.DRI import org.jetbrains.dokka.model.* import org.jetbrains.dokka.model.properties.ExtraProperty import org.jetbrains.dokka.model.properties.MergeStrategy -import org.jetbrains.dokka.pages.PlatformData import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer @@ -12,8 +11,8 @@ class InheritorsExtractorTransformer : DocumentableTransformer { override fun invoke(original: DModule, context: DokkaContext): DModule = original.generateInheritanceMap().let { inheritanceMap -> original.appendInheritors(inheritanceMap) as DModule } - private fun T.appendInheritors(inheritanceMap: Map>>): Documentable = - InheritorsInfo(PlatformDependent(inheritanceMap.getForDRI(dri))).let { info -> + private fun T.appendInheritors(inheritanceMap: Map>>): Documentable = + InheritorsInfo(inheritanceMap.getForDRI(dri)).let { info -> when (this) { is DModule -> copy(packages = packages.map { it.appendInheritors(inheritanceMap) as DPackage }) is DPackage -> copy(classlikes = classlikes.map { it.appendInheritors(inheritanceMap) as DClasslike }) @@ -44,12 +43,12 @@ class InheritorsExtractorTransformer : DocumentableTransformer { } } - private fun InheritorsInfo.isNotEmpty() = this.value.allValues.fold(0) { acc, list -> acc + list.size } > 0 + private fun InheritorsInfo.isNotEmpty() = this.value.values.fold(0) { acc, list -> acc + list.size } > 0 - private fun Map>>.getForDRI(dri: DRI) = - PlatformDependent(map { (v, k) -> + private fun Map>>.getForDRI(dri: DRI) = + map { (v, k) -> v to k[dri] - }.map { (k, v) -> k to v.orEmpty() }.toMap()) + }.map { (k, v) -> k to v.orEmpty() }.toMap() private fun DModule.generateInheritanceMap() = getInheritanceEntriesRec().filterNot { it.second.isEmpty() }.groupBy({ it.first }) { it.second } @@ -58,26 +57,24 @@ class InheritorsExtractorTransformer : DocumentableTransformer { .groupBy({ it.first }) { it.second }.map { (k2, v2) -> k2 to v2.flatten() }.toMap() }.filter { it.second.values.isNotEmpty() }.toMap() - private fun T.getInheritanceEntriesRec(): List>>> = + private fun T.getInheritanceEntriesRec(): List>>> = this.toInheritanceEntries() + children.flatMap { it.getInheritanceEntriesRec() } private fun T.toInheritanceEntries() = (this as? WithSupertypes)?.let { - it.supertypes.map.map { (k, v) -> k to v.map { it to dri } } + it.supertypes.map { (k, v) -> k to v.map { it to dri } } }.orEmpty() } -class InheritorsInfo(val value: PlatformDependent>) : ExtraProperty { +class InheritorsInfo(val value: SourceSetDependent>) : ExtraProperty { companion object : ExtraProperty.Key { override fun mergeStrategyFor(left: InheritorsInfo, right: InheritorsInfo): MergeStrategy = MergeStrategy.Replace( InheritorsInfo( - PlatformDependent( - (left.value.map.entries.toList() + right.value.map.entries.toList()) + (left.value.entries.toList() + right.value.entries.toList()) .groupBy({ it.key }) { it.value } .map { (k, v) -> k to v.flatten() }.toMap() - ) ) ) } diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt index b69c43d3..a886494e 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt @@ -1,9 +1,9 @@ package org.jetbrains.dokka.base.transformers.documentables import org.jetbrains.dokka.model.DModule -import org.jetbrains.dokka.model.PlatformDependent +import org.jetbrains.dokka.model.SourceSetData import org.jetbrains.dokka.model.doc.DocumentationNode -import org.jetbrains.dokka.pages.PlatformData +import org.jetbrains.dokka.model.sourceSet import org.jetbrains.dokka.parsers.MarkdownParser import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer @@ -12,14 +12,14 @@ import java.nio.file.Files import java.nio.file.Paths -internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableTransformer { +internal class ModuleAndPackageDocumentationTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer { - override fun invoke(original: List, context: DokkaContext): List { + override fun invoke(original: List): List { val modulesAndPackagesDocumentation = context.configuration.passesConfigurations .map { - Pair(it.moduleName, it.platformData) to + Pair(it.moduleName, context.sourceSet(it)) to it.includes.map { Paths.get(it) } .also { it.forEach { @@ -50,10 +50,10 @@ internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableT return original.map { module -> val moduleDocumentation = - module.platformData.mapNotNull { pd -> + module.sourceSets.mapNotNull { pd -> val doc = modulesAndPackagesDocumentation[Pair(module.name, pd)] val facade = context.platforms[pd]?.facade - ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.name}") } + ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetName}") } try { doc?.get("Module")?.get(module.name)?.run { pd to MarkdownParser( @@ -68,15 +68,15 @@ internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableT } }.toMap() - val packagesDocumentation = module.packages.map { dPackage -> - dPackage.name to dPackage.platformData.mapNotNull { platformData -> - val doc = modulesAndPackagesDocumentation[Pair(module.name, platformData)] - val facade = context.platforms[platformData]?.facade - ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${platformData.name}") } - val descriptor = facade.resolveSession.getPackageFragment(FqName(dPackage.name)) - ?: return@mapNotNull null.also { context.logger.warn("Could not find descriptor for ${dPackage.name}") } - doc?.get("Package")?.get(dPackage.name)?.run { - platformData to MarkdownParser( + val packagesDocumentation = module.packages.map { + it.name to it.sourceSets.mapNotNull { pd -> + val doc = modulesAndPackagesDocumentation[Pair(module.name, pd)] + val facade = context.platforms[pd]?.facade + ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetName}") } + val descriptor = facade.resolveSession.getPackageFragment(FqName(it.name)) + ?: return@mapNotNull null.also { context.logger.warn("Could not find descriptor for $") } + doc?.get("Package")?.get(it.name)?.run { + pd to MarkdownParser( facade, descriptor, context.logger @@ -86,13 +86,11 @@ internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableT }.toMap() module.copy( - documentation = module.documentation.let { mergeDocumentation(it.map, moduleDocumentation) }, + documentation = mergeDocumentation(module.documentation, moduleDocumentation), packages = module.packages.map { val packageDocumentation = packagesDocumentation[it.name] if (packageDocumentation != null && packageDocumentation.isNotEmpty()) - it.copy(documentation = it.documentation.let { value -> - mergeDocumentation(value.map, packageDocumentation) - }) + it.copy(documentation = mergeDocumentation(it.documentation, packageDocumentation)) else it } @@ -100,10 +98,10 @@ internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableT } } - private fun mergeDocumentation(origin: Map, new: Map) = PlatformDependent( + private fun mergeDocumentation(origin: Map, new: Map) = (origin.asSequence() + new.asSequence()) .distinct() .groupBy({ it.key }, { it.value }) .mapValues { (_, values) -> DocumentationNode(values.flatMap { it.children }) } - ) + } diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt index 778e0498..cb74441e 100644 --- a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt +++ b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt @@ -1,5 +1,6 @@ package org.jetbrains.dokka.base.transformers.pages.comments +import org.jetbrains.dokka.model.SourceSetData import org.jetbrains.dokka.model.doc.DocTag import org.jetbrains.dokka.model.properties.PropertyContainer import org.jetbrains.dokka.pages.* @@ -8,7 +9,7 @@ interface CommentsToContentConverter { fun buildContent( docTag: DocTag, dci: DCI, - platforms: Set, + platforms: Set, styles: Set