Add filtering stategies extension point and fixed constructors in Kotlin-as-Java

plugins/base/src/main/kotlin/DokkaBase.kt

@@ -23,7 +23,9 @@ import org.jetbrains.dokka.base.transformers.pages.merger.*
 import org.jetbrains.dokka.base.transformers.pages.samples.DefaultSamplesTransformer
 import org.jetbrains.dokka.base.transformers.pages.sourcelinks.SourceLinksTransformer
 import org.jetbrains.dokka.base.translators.descriptors.DefaultDescriptorToDocumentableTranslator
+import org.jetbrains.dokka.base.translators.documentables.DefaultDocumentableFilteringStrategies
 import org.jetbrains.dokka.base.translators.documentables.DefaultDocumentableToPageTranslator
+import org.jetbrains.dokka.base.translators.documentables.DocumentableFilteringStrategies
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.base.translators.psi.DefaultPsiToDocumentableTranslator
 import org.jetbrains.dokka.plugability.DokkaPlugin
@@ -39,7 +41,7 @@ class DokkaBase : DokkaPlugin() {
     val htmlPreprocessors by extensionPoint<PageTransformer>()
     val kotlinAnalysis by extensionPoint<KotlinAnalysis>()
     val tabSortingStrategy by extensionPoint<TabSortingStrategy>()
-
+    val documentableFilteringStrategies by extensionPoint<DocumentableFilteringStrategies>()
 
     val descriptorToDocumentableTranslator by extending {
         CoreExtensions.sourceToDocumentableTranslator providing { ctx ->
@@ -115,7 +117,7 @@ class DokkaBase : DokkaPlugin() {
             DefaultDocumentableToPageTranslator(
                 ctx.single(commentsToContentConverter),
                 ctx.single(signatureProvider),
-                ctx.logger
+                ctx
             )
         }
     }
@@ -229,4 +231,8 @@ class DokkaBase : DokkaPlugin() {
             MultimodulePageCreator(it)
         }
     }
+
+    val defaultDocumentableFilteringStrategies by extending {
+        documentableFilteringStrategies with DefaultDocumentableFilteringStrategies
+    }
 }

plugins/base/src/main/kotlin/translators/documentables/DefaultDocumentableFilteringStrategies.kt

@@ -0,0 +1,9 @@
+package org.jetbrains.dokka.base.translators.documentables
+
+import org.jetbrains.dokka.model.DFunction
+import org.jetbrains.dokka.model.PrimaryConstructorExtra
+
+object DefaultDocumentableFilteringStrategies : DocumentableFilteringStrategies {
+    override fun shouldConstructorBeInPage(constructor: DFunction): Boolean =
+        constructor.extra[PrimaryConstructorExtra] == null || constructor.documentation.isNotEmpty()
+}

plugins/base/src/main/kotlin/translators/documentables/DefaultDocumentableToPageTranslator.kt

@@ -4,14 +4,15 @@ import org.jetbrains.dokka.base.signatures.SignatureProvider
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator
 import org.jetbrains.dokka.utilities.DokkaLogger
 
 class DefaultDocumentableToPageTranslator(
     private val commentsToContentConverter: CommentsToContentConverter,
     private val signatureProvider: SignatureProvider,
-    private val logger: DokkaLogger
+    private val context: DokkaContext
 ) : DocumentableToPageTranslator {
     override fun invoke(module: DModule): ModulePageNode =
-        DefaultPageCreator(commentsToContentConverter, signatureProvider, logger).pageForModule(module)
-}
+        DefaultPageCreator(commentsToContentConverter, signatureProvider, context).pageForModule(module)
+}

plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt

@@ -11,13 +11,15 @@ import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.model.properties.WithExtraProperties
 import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import kotlin.reflect.KClass
 import kotlin.reflect.full.isSubclassOf
 import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.resolvers.anchors.SymbolAnchorHint
+import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.transformers.documentables.ClashingDriIdentifier
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
 
 private typealias GroupedTags = Map<KClass<out TagWrapper>, List<Pair<DokkaSourceSet?, TagWrapper>>>
 
@@ -27,8 +29,10 @@ private val specialTags: Set<KClass<out TagWrapper>> =
 open class DefaultPageCreator(
     commentsToContentConverter: CommentsToContentConverter,
     signatureProvider: SignatureProvider,
-    val logger: DokkaLogger
+    val context: DokkaContext
 ) {
+    val logger by context::logger
+
     protected open val contentBuilder = PageContentBuilder(commentsToContentConverter, signatureProvider, logger)
 
     open fun pageForModule(m: DModule) =
@@ -238,7 +242,7 @@ open class DefaultPageCreator(
                     "Constructors",
                     2,
                     ContentKind.Constructors,
-                    c.constructors.filter { it.extra[PrimaryConstructorExtra] == null || it.documentation.isNotEmpty() },
+                    c.constructors.filter(context.single(context.plugin<DokkaBase>().documentableFilteringStrategies)::shouldConstructorBeInPage),
                     c.sourceSets,
                     extra = PropertyContainer.empty<ContentNode>() + SimpleAttr.header("Constructors")
                 ) {

plugins/base/src/main/kotlin/translators/documentables/DocumentableFilteringStrategies.kt

@@ -0,0 +1,7 @@
+package org.jetbrains.dokka.base.translators.documentables
+
+import org.jetbrains.dokka.model.DFunction
+
+interface DocumentableFilteringStrategies {
+    fun shouldConstructorBeInPage(constructor: DFunction): Boolean
+}

plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt

@@ -1,16 +1,15 @@
 package transformerBuilders;
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.pages.RendererSpecificResourcePage
-import org.jetbrains.dokka.pages.RenderingStrategy
+import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.jetbrains.dokka.transformers.pages.PageTransformer
 import org.jetbrains.dokka.transformers.pages.pageMapper
 import org.jetbrains.dokka.transformers.pages.pageScanner
 import org.jetbrains.dokka.transformers.pages.pageStructureTransformer
 import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
 
 class PageTransformerBuilderTest : AbstractCoreTest() {
 
@@ -133,6 +132,43 @@ class PageTransformerBuilderTest : AbstractCoreTest() {
         }
     }
 
+    @Test
+    fun `kotlin constructors tab should not exist`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                }
+            }
+        }
+        testInline(
+            """
+            |/src/main/kotlin/kotlinAsJavaPlugin/Test.kt
+            |package kotlinAsJavaPlugin
+            |
+            |class Test(val xd: Int)
+        """.trimMargin(),
+            configuration
+        ) {
+            pagesGenerationStage = { root ->
+                val content = root.children
+                    .flatMap { it.children<ContentPage>() }
+                    .map { it.content }.single().children
+                    .filterIsInstance<ContentGroup>()
+                    .single { it.dci.kind == ContentKind.Main }.children
+
+                val constructorTabsCount = content.filter { it is ContentHeader }.flatMap {
+                    it.children.filter { it is ContentText }
+                }.count {
+                    (it as? ContentText)?.text == "Constructors"
+                }
+
+                assertEquals(0, constructorTabsCount)
+            }
+        }
+    }
+
+
     private fun <T> Collection<T>.assertCount(n: Int, prefix: String = "") =
         assert(count() == n) { "${prefix}Expected $n, got ${count()}" }
 

plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt

@@ -4,27 +4,36 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.kotlinAsJava.signatures.JavaSignatureProvider
 import org.jetbrains.dokka.kotlinAsJava.transformers.KotlinAsJavaDocumentableTransformer
+import org.jetbrains.dokka.kotlinAsJava.translators.KotlinAsJavaDocumentableFilteringStrategies
 import org.jetbrains.dokka.kotlinAsJava.translators.KotlinAsJavaDocumentableToPageTranslator
 import org.jetbrains.dokka.plugability.DokkaPlugin
 
 class KotlinAsJavaPlugin : DokkaPlugin() {
     val kotlinAsJavaDocumentableTransformer by extending {
         CoreExtensions.documentableTransformer with KotlinAsJavaDocumentableTransformer()
     }
+
     val javaSignatureProvider by extending {
         val dokkaBasePlugin = plugin<DokkaBase>()
         dokkaBasePlugin.signatureProvider providing { ctx ->
             JavaSignatureProvider(ctx.single(dokkaBasePlugin.commentsToContentConverter), ctx.logger)
         } override dokkaBasePlugin.kotlinSignatureProvider
     }
+
+    val defaultDocumentableFilteringStrategies by extending {
+        val dokkaBasePlugin = plugin<DokkaBase>()
+        dokkaBasePlugin.documentableFilteringStrategies with KotlinAsJavaDocumentableFilteringStrategies override
+                dokkaBasePlugin.defaultDocumentableFilteringStrategies
+    }
+
     val kotlinAsJavaDocumentableToPageTranslator by extending {
         val dokkaBasePlugin = plugin<DokkaBase>()
         CoreExtensions.documentableToPageTranslator providing { ctx ->
             KotlinAsJavaDocumentableToPageTranslator(
                 ctx.single(dokkaBasePlugin.commentsToContentConverter),
                 ctx.single(dokkaBasePlugin.signatureProvider),
-                ctx.logger
+                ctx
             )
         } override dokkaBasePlugin.documentableToPageTranslator
     }
-}
+}

plugins/kotlin-as-java/src/main/kotlin/translators/KotlinAsJavaDocumentableFilteringStrategies.kt

@@ -0,0 +1,8 @@
+package org.jetbrains.dokka.kotlinAsJava.translators
+
+import org.jetbrains.dokka.base.translators.documentables.DocumentableFilteringStrategies
+import org.jetbrains.dokka.model.DFunction
+
+object KotlinAsJavaDocumentableFilteringStrategies : DocumentableFilteringStrategies {
+    override fun shouldConstructorBeInPage(constructor: DFunction) = true
+}

plugins/kotlin-as-java/src/main/kotlin/translators/KotlinAsJavaDocumentableToPageTranslator.kt

@@ -2,16 +2,16 @@ package org.jetbrains.dokka.kotlinAsJava.translators
 
 import org.jetbrains.dokka.base.signatures.SignatureProvider
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
-import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator
 
 class KotlinAsJavaDocumentableToPageTranslator(
     private val commentsToContentConverter: CommentsToContentConverter,
     private val signatureProvider: SignatureProvider,
-    private val logger: DokkaLogger
+    private val context: DokkaContext
 ) : DocumentableToPageTranslator {
     override fun invoke(module: DModule): ModulePageNode =
-        KotlinAsJavaPageCreator(commentsToContentConverter, signatureProvider, logger).pageForModule(module)
-}
+        KotlinAsJavaPageCreator(commentsToContentConverter, signatureProvider, context).pageForModule(module)
+}

plugins/kotlin-as-java/src/main/kotlin/translators/KotlinAsJavaPageCreator.kt

@@ -5,12 +5,12 @@ import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentCon
 import org.jetbrains.dokka.base.translators.documentables.DefaultPageCreator
 import org.jetbrains.dokka.model.DProperty
 import org.jetbrains.dokka.pages.MemberPageNode
-import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.dokka.plugability.DokkaContext
 
 class KotlinAsJavaPageCreator(
     commentsToContentConverter: CommentsToContentConverter,
     signatureProvider: SignatureProvider,
-    logger: DokkaLogger
-) : DefaultPageCreator(commentsToContentConverter, signatureProvider, logger) {
+    context: DokkaContext
+) : DefaultPageCreator(commentsToContentConverter, signatureProvider, context) {
     override fun pageForProperty(p: DProperty): MemberPageNode? = null
-}
+}

plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt

@@ -14,6 +14,7 @@ import utils.A
 import utils.Span
 import utils.TestOutputWriterPlugin
 import utils.match
+import kotlin.test.assertEquals
 
 class KotlinAsJavaPluginTest : AbstractCoreTest() {
 
@@ -86,7 +87,10 @@ class KotlinAsJavaPluginTest : AbstractCoreTest() {
                     .map { it.content }
 
                 val children = contentList.flatMap { content ->
-                    content.mainContents.first().cast<ContentGroup>().children
+                    content.mainContents.single { it is ContentGroup }.children // TODO: Fix nesting of groups in PageCreator,
+                        // becuase now there is different level of nesting constructors and properties/functions
+                        // `contentForScope` is called on same level as constructors are
+                        // best solution would be possibility to merge these groups
                         .filterIsInstance<ContentTable>()
                         .filter { it.children.isNotEmpty() }
                 }
@@ -372,6 +376,38 @@ class KotlinAsJavaPluginTest : AbstractCoreTest() {
             }
         }
     }
+
+    @Test
+    fun `kotlin as java constructor`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    sourceRoots = listOf("src/")
+                }
+            }
+        }
+        testInline(
+            """
+            |/src/main/kotlin/kotlinAsJavaPlugin/Test.kt
+            |package kotlinAsJavaPlugin
+            |
+            |class Test(val xd: Int)
+        """.trimMargin(),
+            configuration,
+            cleanupOutput = true
+        ) {
+            pagesGenerationStage = { root ->
+                val content = root.children
+                    .flatMap { it.children<ContentPage>() }
+                    .map { it.content }.single().mainContents
+
+                val text = content.single { it is ContentHeader }.children
+                        .single() as ContentText
+
+                assertEquals("Constructors", text.text)
+            }
+        }
+    }
 }
 
 private val ContentNode.mainContents: List<ContentNode>