diff options
Diffstat (limited to 'plugins')
| -rw-r--r-- | plugins/base/src/main/kotlin/DokkaBase.kt | 15 | ||||
| -rw-r--r-- | plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt | 260 | ||||
| -rw-r--r-- | plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt (renamed from plugins/base/src/main/kotlin/transformers/documentables/DocumentableFilter.kt) | 282 | ||||
| -rw-r--r-- | plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt | 32 |
4 files changed, 310 insertions, 279 deletions
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt index 1d2097ef..cf4ad88f 100644 --- a/plugins/base/src/main/kotlin/DokkaBase.kt +++ b/plugins/base/src/main/kotlin/DokkaBase.kt @@ -14,7 +14,6 @@ import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentableMe import org.jetbrains.dokka.base.transformers.documentables.ModuleAndPackageDocumentationTransformer import org.jetbrains.dokka.base.transformers.documentables.ReportUndocumentedTransformer import org.jetbrains.dokka.base.transformers.pages.annotations.SinceKotlinTransformer -import org.jetbrains.dokka.base.transformers.documentables.DocumentableFilter import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter import org.jetbrains.dokka.base.transformers.pages.comments.DocTagToContentConverter import org.jetbrains.dokka.base.transformers.pages.merger.FallbackPageMergerStrategy @@ -51,8 +50,18 @@ class DokkaBase : DokkaPlugin() { CoreExtensions.documentableMerger with DefaultDocumentableMerger } - val preMergeDocumentableTransformer by extending(isFallback = true) { - CoreExtensions.preMergeDocumentableTransformer providing ::DocumentableFilter + val deprecatedDocumentableFilter by extending(isFallback = true) { + CoreExtensions.preMergeDocumentableTransformer providing ::DeprecatedDocumentableFilterTransformer + } + + val documentableVisbilityFilter by extending(isFallback = true) { + CoreExtensions.preMergeDocumentableTransformer providing ::DocumentableVisibilityFilterTransformer + } + + val emptyPackagesFilter by extending(isFallback = true) { + CoreExtensions.preMergeDocumentableTransformer providing ::EmptyPackagesFilterTransformer order { + after(deprecatedDocumentableFilter, documentableVisbilityFilter) + } } val actualTypealiasAdder by extending { diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt new file mode 100644 index 00000000..27557107 --- /dev/null +++ b/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt @@ -0,0 +1,260 @@ +package org.jetbrains.dokka.base.transformers.documentables + +import org.jetbrains.dokka.DokkaConfiguration +import org.jetbrains.dokka.model.* +import org.jetbrains.dokka.model.properties.WithExtraProperties +import org.jetbrains.dokka.plugability.DokkaContext +import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer + +class DeprecatedDocumentableFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer { + override fun invoke(modules: List<DModule>) = modules.map { original -> + val passOptions = context.configuration.passesConfigurations.first { + original.sourceSets.contains(context.sourceSet(it)) + } + val packageOptions = + passOptions.perPackageOptions + original.let { + DeprecatedDocumentableFilter(passOptions, packageOptions).processModule(it) + } + } + + private class DeprecatedDocumentableFilter( + val globalOptions: DokkaConfiguration.PassConfiguration, + val packageOptions: List<DokkaConfiguration.PackageOptions> + ) { + + fun <T> T.isAllowedInPackage(): Boolean where T : WithExtraProperties<T>, T : Documentable { + val packageName = this.dri.packageName + val condition = packageName != null && packageOptions.firstOrNull { + packageName.startsWith(it.prefix) + }?.skipDeprecated + ?: globalOptions.skipDeprecated + + fun T.isDeprecated() = extra[Annotations]?.let { annotations -> + annotations.content.values.flatten().any { + it.dri.toString() == "kotlin/Deprecated///PointingToDeclaration/" + } + } ?: false + + return !(condition && this.isDeprecated()) + } + + fun processModule(original: DModule) = + filterPackages(original.packages).let { (modified, packages) -> + if (!modified) original + else + DModule( + original.name, + packages = packages, + documentation = original.documentation, + sourceSets = original.sourceSets, + extra = original.extra + ) + } + + + private fun filterPackages(packages: List<DPackage>): Pair<Boolean, List<DPackage>> { + var packagesListChanged = false + val filteredPackages = packages.mapNotNull { pckg -> + var modified = false + val functions = filterFunctions(pckg.functions).let { (listModified, list) -> + modified = modified || listModified + list + } + val properties = filterProperties(pckg.properties).let { (listModified, list) -> + modified = modified || listModified + list + } + val classlikes = filterClasslikes(pckg.classlikes).let { (listModified, list) -> + modified = modified || listModified + list + } + when { + !modified -> pckg + else -> { + packagesListChanged = true + DPackage( + pckg.dri, + functions, + properties, + classlikes, + pckg.typealiases, + pckg.documentation, + pckg.expectPresentInSet, + pckg.sourceSets, + pckg.extra + ) + } + } + } + return Pair(packagesListChanged, filteredPackages) + } + + private fun filterFunctions( + functions: List<DFunction> + ) = functions.filter { it.isAllowedInPackage() }.let { + Pair(it.size != functions.size, it) + } + + private fun filterProperties( + properties: List<DProperty> + ): Pair<Boolean, List<DProperty>> = properties.filter { + it.isAllowedInPackage() + }.let { + Pair(properties.size != it.size, it) + } + + private fun filterEnumEntries(entries: List<DEnumEntry>) = + entries.filter { it.isAllowedInPackage() }.map { entry -> + DEnumEntry( + entry.dri, + entry.name, + entry.documentation, + entry.expectPresentInSet, + filterFunctions(entry.functions).second, + filterProperties(entry.properties).second, + filterClasslikes(entry.classlikes).second, + entry.sourceSets, + entry.extra + ) + } + + private fun filterClasslikes( + classlikeList: List<DClasslike> + ): Pair<Boolean, List<DClasslike>> { + var modified = false + return classlikeList.filter { classlike -> + when (classlike) { + is DClass -> classlike.isAllowedInPackage() + is DInterface -> classlike.isAllowedInPackage() + is DEnum -> classlike.isAllowedInPackage() + is DObject -> classlike.isAllowedInPackage() + is DAnnotation -> classlike.isAllowedInPackage() + } + }.map { classlike -> + fun helper(): DClasslike = when (classlike) { + is DClass -> DClass( + classlike.dri, + classlike.name, + filterFunctions(classlike.constructors).let { + modified = modified || it.first; it.second + }, + filterFunctions(classlike.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(classlike.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(classlike.classlikes).let { + modified = modified || it.first; it.second + }, + classlike.sources, + classlike.visibility, + classlike.companion, + classlike.generics, + classlike.supertypes, + classlike.documentation, + classlike.expectPresentInSet, + classlike.modifier, + classlike.sourceSets, + classlike.extra + ) + is DAnnotation -> DAnnotation( + classlike.name, + classlike.dri, + classlike.documentation, + classlike.expectPresentInSet, + classlike.sources, + filterFunctions(classlike.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(classlike.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(classlike.classlikes).let { + modified = modified || it.first; it.second + }, + classlike.visibility, + classlike.companion, + filterFunctions(classlike.constructors).let { + modified = modified || it.first; it.second + }, + classlike.generics, + classlike.sourceSets, + classlike.extra + ) + is DEnum -> DEnum( + classlike.dri, + classlike.name, + filterEnumEntries(classlike.entries), + classlike.documentation, + classlike.expectPresentInSet, + classlike.sources, + filterFunctions(classlike.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(classlike.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(classlike.classlikes).let { + modified = modified || it.first; it.second + }, + classlike.visibility, + classlike.companion, + filterFunctions(classlike.constructors).let { + modified = modified || it.first; it.second + }, + classlike.supertypes, + classlike.sourceSets, + classlike.extra + ) + is DInterface -> DInterface( + classlike.dri, + classlike.name, + classlike.documentation, + classlike.expectPresentInSet, + classlike.sources, + filterFunctions(classlike.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(classlike.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(classlike.classlikes).let { + modified = modified || it.first; it.second + }, + classlike.visibility, + classlike.companion, + classlike.generics, + classlike.supertypes, + classlike.sourceSets, + classlike.extra + ) + is DObject -> DObject( + classlike.name, + classlike.dri, + classlike.documentation, + classlike.expectPresentInSet, + classlike.sources, + filterFunctions(classlike.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(classlike.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(classlike.classlikes).let { + modified = modified || it.first; it.second + }, + classlike.visibility, + classlike.supertypes, + classlike.sourceSets, + classlike.extra + ) + } + helper() + }.let { + Pair(it.size != classlikeList.size || modified, it) + } + } + } +}
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableFilter.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt index fcead846..0a01680f 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableFilter.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt @@ -2,37 +2,26 @@ package org.jetbrains.dokka.base.transformers.documentables import org.jetbrains.dokka.DokkaConfiguration 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.model.properties.WithExtraProperties import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer -import org.jetbrains.kotlin.utils.addToStdlib.safeAs -internal class DocumentableFilter(val context: DokkaContext) : PreMergeDocumentableTransformer { +class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer { - override fun invoke(modules: List<DModule>): List<DModule> = modules.map { original -> - val packageOptions = - context.configuration.passesConfigurations.first { original.sourceSets.contains(context.sourceSet(it)) } - .perPackageOptions + override fun invoke(modules: List<DModule>) = modules.map { original -> val passOptions = context.configuration.passesConfigurations.first { original.sourceSets.contains(context.sourceSet(it)) } + val packageOptions = + passOptions.perPackageOptions original.let { - DeprecationFilter(passOptions,packageOptions).processModule(it) - }.let { - VisibilityFilter(packageOptions, passOptions).processModule(it) - }.let { - EmptyPackagesFilter(passOptions).processModule(it) + DocumentableVisibilityFilter(packageOptions, passOptions).processModule(it) } } - private class VisibilityFilter( + private class DocumentableVisibilityFilter( val packageOptions: List<DokkaConfiguration.PackageOptions>, val globalOptions: DokkaConfiguration.PassConfiguration ) { - fun Visibility.isAllowedInPackage(packageName: String?) = when (this) { is JavaVisibility.Public, is JavaVisibility.Default, @@ -56,7 +45,6 @@ internal class DocumentableFilter(val context: DokkaContext) : PreMergeDocumenta } - private fun filterPackages(packages: List<DPackage>): Pair<Boolean, List<DPackage>> { var packagesListChanged = false val filteredPackages = packages.mapNotNull { @@ -339,263 +327,5 @@ internal class DocumentableFilter(val context: DokkaContext) : PreMergeDocumenta } return Pair(classlikesListChanged, filteredClasslikes) } - - - } - - private class DeprecationFilter( - val globalOptions: DokkaConfiguration.PassConfiguration, - val packageOptions: List<DokkaConfiguration.PackageOptions> - ) { - - fun <T> T.isAllowedInPackage(): Boolean where T : WithExtraProperties<T>, T : Documentable { - val packageName = this.dri.packageName - val condition = packageName != null && packageOptions.firstOrNull { - packageName.startsWith(it.prefix) - }?.skipDeprecated - ?: globalOptions.skipDeprecated - - fun T.isDeprecated() = extra[Annotations]?.let { annotations -> - annotations.content.values.flatten().any { - it.dri.toString() == "kotlin/Deprecated///PointingToDeclaration/" - } - } ?: false - - return !(condition && this.isDeprecated()) - } - - fun processModule(original: DModule) = - filterPackages(original.packages).let { (modified, packages) -> - if (!modified) original - else - DModule( - original.name, - packages = packages, - documentation = original.documentation, - sourceSets = original.sourceSets, - extra = original.extra - ) - } - - - private fun filterPackages(packages: List<DPackage>): Pair<Boolean, List<DPackage>> { - var packagesListChanged = false - val filteredPackages = packages.mapNotNull { - var modified = false - val functions = filterFunctions(it.functions).let { (listModified, list) -> - modified = modified || listModified - list - } - val properties = filterProperties(it.properties).let { (listModified, list) -> - modified = modified || listModified - list - } - val classlikes = filterClasslikes(it.classlikes).let { (listModified, list) -> - modified = modified || listModified - list - } - when { - !modified -> it - else -> { - packagesListChanged = true - DPackage( - it.dri, - functions, - properties, - classlikes, - it.typealiases, - it.documentation, - it.expectPresentInSet, - it.sourceSets, - it.extra - ) - } - } - } - return Pair(packagesListChanged, filteredPackages) - } - - private fun filterFunctions( - functions: List<DFunction> - ) = functions.filter { it.isAllowedInPackage() }.let { - Pair(it.size != functions.size, it) - } - - private fun filterProperties( - properties: List<DProperty> - ): Pair<Boolean, List<DProperty>> = properties.filter { - it.isAllowedInPackage() - }.let { - Pair(properties.size != it.size, it) - } - - private fun filterEnumEntries(entries: List<DEnumEntry>) = - entries.filter { it.isAllowedInPackage() }.map { entry -> - DEnumEntry( - entry.dri, - entry.name, - entry.documentation, - entry.expectPresentInSet, - filterFunctions(entry.functions).second, - filterProperties(entry.properties).second, - filterClasslikes(entry.classlikes).second, - entry.sourceSets, - entry.extra - ) - } - - private fun filterClasslikes( - classlikeList: List<DClasslike> - ): Pair<Boolean, List<DClasslike>> { - var modified = false - return classlikeList.filter { - when (it) { - is DClass -> it.isAllowedInPackage() - is DInterface -> it.isAllowedInPackage() - is DEnum -> it.isAllowedInPackage() - is DObject -> it.isAllowedInPackage() - is DAnnotation -> it.isAllowedInPackage() - } - }.map { - fun helper(): DClasslike = when (it) { - is DClass -> DClass( - it.dri, - it.name, - filterFunctions(it.constructors).let { - modified = modified || it.first; it.second - }, - filterFunctions(it.functions).let { - modified = modified || it.first; it.second - }, - filterProperties(it.properties).let { - modified = modified || it.first; it.second - }, - filterClasslikes(it.classlikes).let { - modified = modified || it.first; it.second - }, - it.sources, - it.visibility, - it.companion, - it.generics, - it.supertypes, - it.documentation, - it.expectPresentInSet, - it.modifier, - it.sourceSets, - it.extra - ) - is DAnnotation -> DAnnotation( - it.name, - it.dri, - it.documentation, - it.expectPresentInSet, - it.sources, - filterFunctions(it.functions).let { - modified = modified || it.first; it.second - }, - filterProperties(it.properties).let { - modified = modified || it.first; it.second - }, - filterClasslikes(it.classlikes).let { - modified = modified || it.first; it.second - }, - it.visibility, - it.companion, - filterFunctions(it.constructors).let { - modified = modified || it.first; it.second - }, - it.generics, - it.sourceSets, - it.extra - ) - is DEnum -> DEnum( - it.dri, - it.name, - filterEnumEntries(it.entries), - it.documentation, - it.expectPresentInSet, - it.sources, - filterFunctions(it.functions).let { - modified = modified || it.first; it.second - }, - filterProperties(it.properties).let { - modified = modified || it.first; it.second - }, - filterClasslikes(it.classlikes).let { - modified = modified || it.first; it.second - }, - it.visibility, - it.companion, - filterFunctions(it.constructors).let { - modified = modified || it.first; it.second - }, - it.supertypes, - it.sourceSets, - it.extra - ) - is DInterface -> DInterface( - it.dri, - it.name, - it.documentation, - it.expectPresentInSet, - it.sources, - filterFunctions(it.functions).let { - modified = modified || it.first; it.second - }, - filterProperties(it.properties).let { - modified = modified || it.first; it.second - }, - filterClasslikes(it.classlikes).let { - modified = modified || it.first; it.second - }, - it.visibility, - it.companion, - it.generics, - it.supertypes, - it.sourceSets, - it.extra - ) - is DObject -> DObject( - it.name, - it.dri, - it.documentation, - it.expectPresentInSet, - it.sources, - filterFunctions(it.functions).let { - modified = modified || it.first; it.second - }, - filterProperties(it.properties).let { - modified = modified || it.first; it.second - }, - filterClasslikes(it.classlikes).let { - modified = modified || it.first; it.second - }, - it.visibility, - it.supertypes, - it.sourceSets, - it.extra - ) - } - helper() - }.let { - Pair(it.size != classlikeList.size || modified, it) - } - } - } - - private class EmptyPackagesFilter( - val passOptions: DokkaConfiguration.PassConfiguration - ) { - fun DPackage.shouldBeSkipped() = passOptions.skipEmptyPackages && - functions.isEmpty() && - properties.isEmpty() && - classlikes.isEmpty() - - fun processModule(module: DModule) = module.copy( - packages = module.packages.mapNotNull { pckg -> - if (pckg.shouldBeSkipped()) null - else pckg - } - ) } }
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt new file mode 100644 index 00000000..6b29531c --- /dev/null +++ b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt @@ -0,0 +1,32 @@ +package org.jetbrains.dokka.base.transformers.documentables + +import org.jetbrains.dokka.DokkaConfiguration +import org.jetbrains.dokka.model.DModule +import org.jetbrains.dokka.model.DPackage +import org.jetbrains.dokka.model.sourceSet +import org.jetbrains.dokka.plugability.DokkaContext +import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer + +class EmptyPackagesFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer { + override fun invoke(modules: List<DModule>): List<DModule> = modules.map { original -> + val passOptions = context.configuration.passesConfigurations.first { + original.sourceSets.contains(context.sourceSet(it)) + } + original.let { + EmptyPackagesFilter(passOptions).processModule(it) + } + } + + private class EmptyPackagesFilter( + val passOptions: DokkaConfiguration.PassConfiguration + ) { + fun DPackage.shouldBeSkipped() = passOptions.skipEmptyPackages && + functions.isEmpty() && + properties.isEmpty() && + classlikes.isEmpty() + + fun processModule(module: DModule) = module.copy( + packages = module.packages.filter { !it.shouldBeSkipped() } + ) + } +}
\ No newline at end of file |