From 34cb9a33a0dc43f45cd66f657a12e1db56ccb475 Mon Sep 17 00:00:00 2001 From: vmishenev Date: Mon, 8 Nov 2021 15:49:06 +0300 Subject: [PATCH] Allow filtering of property setter --- ...DocumentableVisibilityFilterTransformer.kt | 47 +++++++++++++++++-- ...yConditionDocumentableFilterTransformer.kt | 19 ++++++-- .../kotlin/filter/VisibilityFilterTest.kt | 31 ++++++++++++ .../transformers/SuppressTagFilterTest.kt | 21 +++++++++ 4 files changed, 110 insertions(+), 8 deletions(-) diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt index 8b3b4304f3..ca364dae96 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt @@ -83,6 +83,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe private fun alwaysTrue(a: T, p: DokkaSourceSet) = true private fun alwaysFalse(a: T, p: DokkaSourceSet) = false + private fun alwaysNoModify(a: T, sourceSets: Set) = Pair(false, a) private fun WithVisibility.visibilityForPlatform(data: DokkaSourceSet): Visibility? = visibility[data] @@ -99,13 +100,18 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe private fun List.transform( additionalCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysTrue, alternativeCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysFalse, - recreate: (T, Set) -> T + modify: (T, Set) -> Pair = ::alwaysNoModify, + recreate: (T, Set) -> T, ): Pair> where T : Documentable, T : WithVisibility { var changed = false val values = mapNotNull { t -> val filteredPlatforms = t.filterPlatforms(additionalCondition, alternativeCondition) when (filteredPlatforms.size) { - t.visibility.size -> t + t.visibility.size -> { + val (wasChanged, element) = modify(t, filteredPlatforms) + changed = changed || wasChanged + element + } 0 -> { changed = true null @@ -142,9 +148,37 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe private fun filterProperties( properties: List, - additionalCondition: (DProperty, DokkaSourceSet) -> Boolean = ::alwaysTrue - ): Pair> = - properties.transform(additionalCondition, ::hasVisibleAccessorsForPlatform) { original, filteredPlatforms -> + additionalCondition: (DProperty, DokkaSourceSet) -> Boolean = ::alwaysTrue, + additionalConditionAccessors: (DFunction, DokkaSourceSet) -> Boolean = ::alwaysTrue + ): Pair> { + + val modifier: (DProperty, Set) -> Pair = + { original, filteredPlatforms -> + val setter = original.setter?.let { filterFunctions(listOf(it), additionalConditionAccessors) } + val getter = original.getter?.let { filterFunctions(listOf(it), additionalConditionAccessors) } + + val modified = setter?.first == true || getter?.first == true + + Pair(modified, + if (modified) + with(original) { + copy( + setter = setter?.second?.firstOrNull(), + getter = getter?.second?.firstOrNull() + ) + } + else original + ) + } + + return properties.transform( + additionalCondition, + ::hasVisibleAccessorsForPlatform, + modifier + ) { original, filteredPlatforms -> + val setter = original.setter?.let { filterFunctions(listOf(it), additionalConditionAccessors) } + val getter = original.getter?.let { filterFunctions(listOf(it), additionalConditionAccessors) } + with(original) { copy( documentation = documentation.filtered(filteredPlatforms), @@ -153,9 +187,12 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe visibility = visibility.filtered(filteredPlatforms), sourceSets = filteredPlatforms, generics = generics.mapNotNull { it.filter(filteredPlatforms) }, + setter = setter?.second?.firstOrNull(), + getter = getter?.second?.firstOrNull() ) } } + } private fun filterEnumEntries(entries: List, filteredPlatforms: Set): Pair> = entries.foldRight(Pair(false, emptyList())) { entry, acc -> diff --git a/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt index 0bcb6fd5ea..918ff1bf92 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt @@ -27,7 +27,7 @@ abstract class SuppressedByConditionDocumentableFilterTransformer(val context: D val classlikes = dPackage.classlikes.map { processClassLike(it) } val typeAliases = dPackage.typealiases.map { processMember(it) } val functions = dPackage.functions.map { processMember(it) } - val properies = dPackage.properties.map { processMember(it) } + val properies = dPackage.properties.map { processProperty(it) } val wasChanged = (classlikes + typeAliases + functions + properies).any { it.changed } return (dPackage.takeIf { !wasChanged } ?: dPackage.copy( @@ -43,7 +43,7 @@ abstract class SuppressedByConditionDocumentableFilterTransformer(val context: D val functions = classlike.functions.map { processMember(it) } val classlikes = classlike.classlikes.map { processClassLike(it) } - val properties = classlike.properties.map { processMember(it) } + val properties = classlike.properties.map { processProperty(it) } val companion = (classlike as? WithCompanion)?.companion?.let { processClassLike(it) } val wasClasslikeChanged = (functions + classlikes + properties).any { it.changed } || companion?.changed == true @@ -104,7 +104,7 @@ abstract class SuppressedByConditionDocumentableFilterTransformer(val context: D if (shouldBeSuppressed(dEnumEntry)) return DocumentableWithChanges.filteredDocumentable() val functions = dEnumEntry.functions.map { processMember(it) } - val properties = dEnumEntry.properties.map { processMember(it) } + val properties = dEnumEntry.properties.map { processProperty(it) } val classlikes = dEnumEntry.classlikes.map { processClassLike(it) } val wasChanged = (functions + properties + classlikes).any { it.changed } @@ -115,6 +115,19 @@ abstract class SuppressedByConditionDocumentableFilterTransformer(val context: D )).let { DocumentableWithChanges(it, wasChanged) } } + private fun processProperty(dProperty: DProperty): DocumentableWithChanges { + if (shouldBeSuppressed(dProperty)) return DocumentableWithChanges.filteredDocumentable() + + val getter = dProperty.getter?.let { processMember(it) } ?: DocumentableWithChanges(null, false) + val setter = dProperty.setter?.let { processMember(it) } ?: DocumentableWithChanges(null, false) + + val wasChanged = getter.changed || setter.changed + return (dProperty.takeIf { !wasChanged } ?: dProperty.copy( + getter = getter.documentable, + setter = setter.documentable + )).let { DocumentableWithChanges(it, wasChanged) } + } + private fun processMember(member: T): DocumentableWithChanges = if (shouldBeSuppressed(member)) DocumentableWithChanges.filteredDocumentable() else DocumentableWithChanges(member, false) diff --git a/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt b/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt index ffefaaea39..1bb2d5d002 100644 --- a/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt +++ b/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt @@ -104,6 +104,37 @@ class VisibilityFilterTest : BaseAbstractTest() { } } + @Test + fun `private setter with false global includeNonPublic`() { + val configuration = dokkaConfiguration { + sourceSets { + sourceSet { + includeNonPublic = false + sourceRoots = listOf("src/main/kotlin/basic/Test.kt") + } + } + } + + testInline( + """ + |/src/main/kotlin/basic/Test.kt + |package example + | + |var property: Int = 0 + |private set + | + | + """.trimMargin(), + configuration + ) { + preMergeDocumentablesTransformationStage = { + Assertions.assertNull( + it.first().packages.first().properties.first().setter + ) + } + } + } + @Test fun `private function with false global true package includeNonPublic`() { val configuration = dokkaConfiguration { diff --git a/plugins/base/src/test/kotlin/transformers/SuppressTagFilterTest.kt b/plugins/base/src/test/kotlin/transformers/SuppressTagFilterTest.kt index fb8f520eed..4c4267609a 100644 --- a/plugins/base/src/test/kotlin/transformers/SuppressTagFilterTest.kt +++ b/plugins/base/src/test/kotlin/transformers/SuppressTagFilterTest.kt @@ -2,6 +2,7 @@ package transformers import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest import org.jetbrains.dokka.model.DEnum +import org.jetbrains.dokka.model.DProperty import org.jetbrains.dokka.model.WithCompanion import org.junit.jupiter.api.Test import kotlin.test.assertEquals @@ -88,6 +89,26 @@ class SuppressTagFilterTest : BaseAbstractTest() { } } + @Test + fun `should filter setter`() { + testInline( + """ + |/src/suppressed/Suppressed.kt + |var property: Int + |/** @suppress */ + |private set + """.trimIndent(), configuration + ) { + preMergeDocumentablesTransformationStage = { modules -> + val prop = modules.flatMap { it.packages }.flatMap { it.properties } + .firstOrNull { it.name == "property" } as? DProperty + assertNotNull(prop) + assertNotNull(prop.getter) + assertNull(prop.setter) + } + } + } + @Test fun `should filter top level type aliases`() { testInline(