From 7cf644f064868934fe8dcb46ab150f25fab8e8c8 Mon Sep 17 00:00:00 2001 From: Marcin Aman Date: Mon, 1 Mar 2021 13:50:17 +0100 Subject: Add ability to suppress obvious functions like equals, toString... (#1758) * Add ability to suppress obvious functions like equals, toString... * Add ability to suppress obvious functions like equals, toString... --- ...bviousFunctionsDocumentableFilterTransformer.kt | 11 +++ .../documentables/SuppressTagDocumentableFilter.kt | 2 +- ...ssedByConditionDocumentableFilterTransformer.kt | 110 +++++++++++++++++++++ ...SuppressedByTagDocumentableFilterTransformer.kt | 110 --------------------- 4 files changed, 122 insertions(+), 111 deletions(-) create mode 100644 plugins/base/src/main/kotlin/transformers/documentables/ObviousFunctionsDocumentableFilterTransformer.kt create mode 100644 plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt delete mode 100644 plugins/base/src/main/kotlin/transformers/documentables/SuppressedByTagDocumentableFilterTransformer.kt (limited to 'plugins/base/src/main/kotlin/transformers/documentables') diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ObviousFunctionsDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ObviousFunctionsDocumentableFilterTransformer.kt new file mode 100644 index 00000000..57d7268e --- /dev/null +++ b/plugins/base/src/main/kotlin/transformers/documentables/ObviousFunctionsDocumentableFilterTransformer.kt @@ -0,0 +1,11 @@ +package org.jetbrains.dokka.base.transformers.documentables + +import org.jetbrains.dokka.model.DFunction +import org.jetbrains.dokka.model.Documentable +import org.jetbrains.dokka.model.ObviousMember +import org.jetbrains.dokka.plugability.DokkaContext + +class ObviousFunctionsDocumentableFilterTransformer(context: DokkaContext) : SuppressedByConditionDocumentableFilterTransformer(context) { + override fun shouldBeSuppressed(d: Documentable): Boolean = + context.configuration.suppressObviousFunctions && d is DFunction && d.extra[ObviousMember] != null +} \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/SuppressTagDocumentableFilter.kt b/plugins/base/src/main/kotlin/transformers/documentables/SuppressTagDocumentableFilter.kt index 7efb23ab..a297908d 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/SuppressTagDocumentableFilter.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/SuppressTagDocumentableFilter.kt @@ -6,7 +6,7 @@ import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.model.doc.Suppress class SuppressTagDocumentableFilter(val dokkaContext: DokkaContext) : - SuppressedByTagDocumentableFilterTransformer(dokkaContext) { + SuppressedByConditionDocumentableFilterTransformer(dokkaContext) { override fun shouldBeSuppressed(d: Documentable): Boolean = d.documentation.any { (_, docs) -> docs.dfs { it is Suppress } != null } } \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt new file mode 100644 index 00000000..b0bdd4b7 --- /dev/null +++ b/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt @@ -0,0 +1,110 @@ +package org.jetbrains.dokka.base.transformers.documentables + +import org.jetbrains.dokka.model.* +import org.jetbrains.dokka.plugability.DokkaContext +import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer + +abstract class SuppressedByConditionDocumentableFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer { + override fun invoke(modules: List): List = + modules.map { module -> + val (documentable, wasChanged) = processModule(module) + documentable.takeIf { wasChanged } ?: module + } + + abstract fun shouldBeSuppressed(d: Documentable): Boolean + + private fun processModule(module: DModule): DocumentableWithChanges { + val afterProcessing = module.packages.map { processPackage(it) } + val processedModule = module.takeIf { afterProcessing.none { it.changed } } + ?: module.copy(packages = afterProcessing.mapNotNull { it.documentable }) + return DocumentableWithChanges(processedModule, afterProcessing.any { it.changed }) + } + + private fun processPackage(dPackage: DPackage): DocumentableWithChanges { + 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 wasChanged = (classlikes + typeAliases + functions + properies).any { it.changed } + return (dPackage.takeIf { !wasChanged } ?: dPackage.copy( + classlikes = classlikes.mapNotNull { it.documentable }, + typealiases = typeAliases.mapNotNull { it.documentable }, + functions = functions.mapNotNull { it.documentable }, + properties = properies.mapNotNull { it.documentable } + )).let { processedPackage -> DocumentableWithChanges(processedPackage, wasChanged) } + } + + private fun processClassLike(classlike: DClasslike): DocumentableWithChanges { + if (shouldBeSuppressed(classlike)) return DocumentableWithChanges.filteredDocumentable() + + val functions = classlike.functions.map { processMember(it) } + val classlikes = classlike.classlikes.map { processClassLike(it) } + val properties = classlike.properties.map { processMember(it) } + val companion = (classlike as? WithCompanion)?.companion?.let { processClassLike(it) } + + val wasClasslikeChanged = (functions + classlikes + properties).any { it.changed } || companion?.changed == true + return when (classlike) { + is DClass -> { + val constructors = classlike.constructors.map { processMember(it) } + val wasClassChange = + wasClasslikeChanged || constructors.any { it.changed } + (classlike.takeIf { !wasClassChange } ?: classlike.copy( + functions = functions.mapNotNull { it.documentable }, + classlikes = classlikes.mapNotNull { it.documentable }, + properties = properties.mapNotNull { it.documentable }, + constructors = constructors.mapNotNull { it.documentable }, + companion = companion?.documentable as? DObject + )).let { DocumentableWithChanges(it, wasClassChange) } + } + is DInterface -> (classlike.takeIf { !wasClasslikeChanged } ?: classlike.copy( + functions = functions.mapNotNull { it.documentable }, + classlikes = classlikes.mapNotNull { it.documentable }, + properties = properties.mapNotNull { it.documentable }, + companion = companion?.documentable as? DObject + )).let { DocumentableWithChanges(it, wasClasslikeChanged) } + is DObject -> (classlike.takeIf { !wasClasslikeChanged } ?: classlike.copy( + functions = functions.mapNotNull { it.documentable }, + classlikes = classlikes.mapNotNull { it.documentable }, + properties = properties.mapNotNull { it.documentable }, + )).let { DocumentableWithChanges(it, wasClasslikeChanged) } + is DAnnotation -> { + val constructors = classlike.constructors.map { processMember(it) } + val wasClassChange = + wasClasslikeChanged || constructors.any { it.changed } + (classlike.takeIf { !wasClassChange } ?: classlike.copy( + functions = functions.mapNotNull { it.documentable }, + classlikes = classlikes.mapNotNull { it.documentable }, + properties = properties.mapNotNull { it.documentable }, + constructors = constructors.mapNotNull { it.documentable }, + companion = companion?.documentable as? DObject + )).let { DocumentableWithChanges(it, wasClassChange) } + } + is DEnum -> { + val constructors = classlike.constructors.map { processMember(it) } + val entries = classlike.entries.map { processMember(it) } + val wasClassChange = + wasClasslikeChanged || (constructors + entries).any { it.changed } + (classlike.takeIf { !wasClassChange } ?: classlike.copy( + functions = functions.mapNotNull { it.documentable }, + classlikes = classlikes.mapNotNull { it.documentable }, + properties = properties.mapNotNull { it.documentable }, + constructors = constructors.mapNotNull { it.documentable }, + companion = companion?.documentable as? DObject, + entries = entries.mapNotNull { it.documentable } + )).let { DocumentableWithChanges(it, wasClassChange) } + } + } + } + + private fun processMember(member: T): DocumentableWithChanges = + if (shouldBeSuppressed(member)) DocumentableWithChanges.filteredDocumentable() + else DocumentableWithChanges(member, false) + + private data class DocumentableWithChanges(val documentable: T?, val changed: Boolean = false) { + companion object { + fun filteredDocumentable(): DocumentableWithChanges = + DocumentableWithChanges(null, true) + } + } +} \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByTagDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByTagDocumentableFilterTransformer.kt deleted file mode 100644 index f40abe70..00000000 --- a/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByTagDocumentableFilterTransformer.kt +++ /dev/null @@ -1,110 +0,0 @@ -package org.jetbrains.dokka.base.transformers.documentables - -import org.jetbrains.dokka.model.* -import org.jetbrains.dokka.plugability.DokkaContext -import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer - -abstract class SuppressedByTagDocumentableFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer { - override fun invoke(modules: List): List = - modules.map { module -> - val (documentable, wasChanged) = processModule(module) - documentable.takeIf { wasChanged } ?: module - } - - abstract fun shouldBeSuppressed(d: Documentable): Boolean - - private fun processModule(module: DModule): DocumentableWithChanges { - val afterProcessing = module.packages.map { processPackage(it) } - val processedModule = module.takeIf { afterProcessing.none { it.changed } } - ?: module.copy(packages = afterProcessing.mapNotNull { it.documentable }) - return DocumentableWithChanges(processedModule, afterProcessing.any { it.changed }) - } - - private fun processPackage(dPackage: DPackage): DocumentableWithChanges { - 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 wasChanged = (classlikes + typeAliases + functions + properies).any { it.changed } - return (dPackage.takeIf { !wasChanged } ?: dPackage.copy( - classlikes = classlikes.mapNotNull { it.documentable }, - typealiases = typeAliases.mapNotNull { it.documentable }, - functions = functions.mapNotNull { it.documentable }, - properties = properies.mapNotNull { it.documentable } - )).let { processedPackage -> DocumentableWithChanges(processedPackage, wasChanged) } - } - - private fun processClassLike(classlike: DClasslike): DocumentableWithChanges { - if (shouldBeSuppressed(classlike)) return DocumentableWithChanges.filteredDocumentable() - - val functions = classlike.functions.map { processMember(it) } - val classlikes = classlike.classlikes.map { processClassLike(it) } - val properties = classlike.properties.map { processMember(it) } - val companion = (classlike as? WithCompanion)?.companion?.let { processClassLike(it) } - - val wasClasslikeChanged = (functions + classlikes + properties).any { it.changed } || companion?.changed == true - return when (classlike) { - is DClass -> { - val constructors = classlike.constructors.map { processMember(it) } - val wasClassChange = - wasClasslikeChanged || constructors.any { it.changed } - (classlike.takeIf { !wasClassChange } ?: classlike.copy( - functions = functions.mapNotNull { it.documentable }, - classlikes = classlikes.mapNotNull { it.documentable }, - properties = properties.mapNotNull { it.documentable }, - constructors = constructors.mapNotNull { it.documentable }, - companion = companion?.documentable as? DObject - )).let { DocumentableWithChanges(it, wasClassChange) } - } - is DInterface -> (classlike.takeIf { !wasClasslikeChanged } ?: classlike.copy( - functions = functions.mapNotNull { it.documentable }, - classlikes = classlikes.mapNotNull { it.documentable }, - properties = properties.mapNotNull { it.documentable }, - companion = companion?.documentable as? DObject - )).let { DocumentableWithChanges(it, wasClasslikeChanged) } - is DObject -> (classlike.takeIf { !wasClasslikeChanged } ?: classlike.copy( - functions = functions.mapNotNull { it.documentable }, - classlikes = classlikes.mapNotNull { it.documentable }, - properties = properties.mapNotNull { it.documentable }, - )).let { DocumentableWithChanges(it, wasClasslikeChanged) } - is DAnnotation -> { - val constructors = classlike.constructors.map { processMember(it) } - val wasClassChange = - wasClasslikeChanged || constructors.any { it.changed } - (classlike.takeIf { !wasClassChange } ?: classlike.copy( - functions = functions.mapNotNull { it.documentable }, - classlikes = classlikes.mapNotNull { it.documentable }, - properties = properties.mapNotNull { it.documentable }, - constructors = constructors.mapNotNull { it.documentable }, - companion = companion?.documentable as? DObject - )).let { DocumentableWithChanges(it, wasClassChange) } - } - is DEnum -> { - val constructors = classlike.constructors.map { processMember(it) } - val entries = classlike.entries.map { processMember(it) } - val wasClassChange = - wasClasslikeChanged || (constructors + entries).any { it.changed } - (classlike.takeIf { !wasClassChange } ?: classlike.copy( - functions = functions.mapNotNull { it.documentable }, - classlikes = classlikes.mapNotNull { it.documentable }, - properties = properties.mapNotNull { it.documentable }, - constructors = constructors.mapNotNull { it.documentable }, - companion = companion?.documentable as? DObject, - entries = entries.mapNotNull { it.documentable } - )).let { DocumentableWithChanges(it, wasClassChange) } - } - } - } - - private fun processMember(member: T): DocumentableWithChanges = - if (shouldBeSuppressed(member)) DocumentableWithChanges.filteredDocumentable() - else DocumentableWithChanges(member, false) - - private data class DocumentableWithChanges(val documentable: T?, val changed: Boolean = false) { - companion object { - fun filteredDocumentable(): DocumentableWithChanges = - DocumentableWithChanges(null, true) - } - } -} \ No newline at end of file -- cgit