Tabs for sections v1

1 files changed, 132 insertions, 105 deletions

diff --git a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
index d4ee88d8..409b0d6f 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
@@ -7,6 +7,7 @@ import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder.Doc
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.*
 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
@@ -67,6 +68,7 @@ open class DefaultPageCreator(
         group(kind = ContentKind.Cover) {
             header(1, m.name)
         }
+        +contentForDescription(m)
         +contentForComments(m)
         block("Packages", 2, ContentKind.Packages, m.packages, m.sourceSets.toSet()) {
             link(it.name, it.dri)
@@ -78,14 +80,17 @@ open class DefaultPageCreator(
     protected open fun contentForPackage(p: DPackage) = contentBuilder.contentFor(p) {
         group(kind = ContentKind.Cover) {
             header(1, "Package ${p.name}")
+            +contentForDescription(p)
         }
-        +contentForComments(p)
-        +contentForScope(p, p.dri, p.sourceSets)
-        block("Type aliases", 2, ContentKind.TypeAliases, p.typealiases, p.sourceSets.toSet()) {
-            link(it.name, it.dri, kind = ContentKind.Main)
-            sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
-                +buildSignature(it)
-                contentForBrief(it)
+        group(styles = setOf(ContentStyle.TabbedContent)){
+            +contentForComments(p)
+            +contentForScope(p, p.dri, p.sourceSets)
+            block("Type aliases", 2, ContentKind.TypeAliases, p.typealiases, p.sourceSets.toSet(), extra = mainExtra + SimpleAttr.header("Type aliases")) {
+                link(it.name, it.dri, kind = ContentKind.Main)
+                sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = emptySet()) {
+                    +buildSignature(it)
+                    contentForBrief(it)
+                }
             }
         }
     }
@@ -95,9 +100,9 @@ open class DefaultPageCreator(
         dri: DRI,
         sourceSets: List<SourceSetData>
     ) = contentBuilder.contentFor(s as Documentable) {
-        divergentBlock("Types", s.classlikes, ContentKind.Classlikes)
-        divergentBlock("Functions", s.functions, ContentKind.Functions)
-        block("Properties", 2, ContentKind.Properties, s.properties, sourceSets.toSet()) {
+        divergentBlock("Types", s.classlikes, ContentKind.Classlikes, extra = mainExtra + SimpleAttr.header("Types"))
+        divergentBlock("Functions", s.functions, ContentKind.Functions, extra = mainExtra + SimpleAttr.header( "Functions"))
+        block("Properties", 2, ContentKind.Properties, s.properties, sourceSets.toSet(), extra = mainExtra + SimpleAttr.header( "Properties")) {
             link(it.name, it.dri, kind = ContentKind.Main)
             sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                 +buildSignature(it)
@@ -122,7 +127,8 @@ open class DefaultPageCreator(
                         },
                     DCI(setOf(dri), ContentKind.Inheritors),
                     sourceSets.toSet(),
-                    style = emptySet()
+                    style = emptySet(),
+                    extra = mainExtra + SimpleAttr.header( "Inheritors")
                 )
             }
         }
@@ -132,9 +138,12 @@ open class DefaultPageCreator(
         group(kind = ContentKind.Cover) {
             header(1, e.name)
             +buildSignature(e)
+            +contentForDescription(e)
+        }
+        group(styles = setOf(ContentStyle.TabbedContent)){
+            +contentForComments(e)
+            +contentForScope(e, e.dri, e.sourceSets)
         }
-        +contentForComments(e)
-        +contentForScope(e, e.dri, e.sourceSets)
     }
 
     protected open fun contentForClasslike(c: DClasslike) = contentBuilder.contentFor(c) {
@@ -142,36 +151,39 @@ open class DefaultPageCreator(
             header(1, c.name.orEmpty())
                 sourceSetDependentHint(c.dri, c.sourceSets.toSet()) {
                 +buildSignature(c)
+                +contentForDescription(c)
             }
         }
-        +contentForComments(c)
-
-        if (c is WithConstructors) {
-            block(
-                "Constructors",
-                2,
-                ContentKind.Constructors,
-                c.constructors.filter { it.extra[PrimaryConstructorExtra] == null },
-                c.sourceSets.toSet()
-            ) {
-                link(it.name, it.dri, kind = ContentKind.Main)
-                sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
-                    +buildSignature(it)
-                    contentForBrief(it)
+
+        group(styles = setOf(ContentStyle.TabbedContent)) {
+            +contentForComments(c)
+            if (c is WithConstructors) {
+                block(
+                    "Constructors",
+                    2,
+                    ContentKind.Constructors,
+                    c.constructors.filter { it.extra[PrimaryConstructorExtra] == null },
+                    c.sourceSets.toSet(),
+                    extra = PropertyContainer.empty<ContentNode>() + SimpleAttr.header("Constructors")
+                ) {
+                    link(it.name, it.dri, kind = ContentKind.Main)
+                    sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = emptySet()) {
+                        +buildSignature(it)
+                        contentForBrief(it)
+                    }
                 }
             }
-        }
-        if (c is DEnum) {
-            block("Entries", 2, ContentKind.Classlikes, c.entries, c.sourceSets.toSet()) {
-                link(it.name, it.dri)
-                sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
-                    +buildSignature(it)
-                    contentForBrief(it)
+            if (c is DEnum) {
+                block("Entries", 2, ContentKind.Classlikes, c.entries, c.sourceSets.toSet(), extra = mainExtra + SimpleAttr.header("Entries"), styles = emptySet()) {
+                    link(it.name, it.dri)
+                    sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
+                        +buildSignature(it)
+                        contentForBrief(it)
+                    }
                 }
             }
+            +contentForScope(c, c.dri, c.sourceSets)
         }
-
-        +contentForScope(c, c.dri, c.sourceSets)
     }
 
     @Suppress("UNCHECKED_CAST")
@@ -188,16 +200,16 @@ open class DefaultPageCreator(
     private inline fun <reified T : TagWrapper> GroupedTags.isNotEmptyForTag(): Boolean =
         this[T::class]?.isNotEmpty() ?: false
 
-    protected open fun contentForComments(
+    protected open fun contentForDescription(
         d: Documentable
-    ): List<ContentNode> {
+    ): ContentNode {
         val tags: GroupedTags = d.documentation.flatMap { (pd, doc) ->
             doc.children.asSequence().map { pd to it }.toList()
         }.groupBy { it.second::class }
 
         val platforms = d.sourceSets
 
-        fun DocumentableContentBuilder.contentForDescription() {
+        return contentBuilder.contentFor(d) {
             val description = tags.withTypeUnnamed<Description>()
             if (description.any { it.value.root.children.isNotEmpty() }) {
                 platforms.forEach { platform ->
@@ -208,34 +220,60 @@ open class DefaultPageCreator(
                     }
                 }
             }
+
+            val unnamedTags: List<SourceSetDependent<TagWrapper>> =
+                tags.filterNot { (k, _) -> k.isSubclassOf(NamedTagWrapper::class) || k in specialTags }
+                    .map { (_, v) -> v.mapNotNull { (k,v) -> k?.let { it to v } }.toMap() }
+            platforms.forEach { platform ->
+                unnamedTags.forEach { pdTag ->
+                    pdTag[platform]?.also { tag ->
+                        group(sourceSets = setOf(platform)) {
+                            header(4, tag.toHeaderString())
+                            comment(tag.root)
+                        }
+                    }
+                }
+            }
         }
+    }
+
+    protected open fun contentForComments(
+        d: Documentable
+    ): List<ContentNode> {
+        val tags: GroupedTags = d.documentation.flatMap { (pd, doc) ->
+            doc.children.asSequence().map { pd to it }.toList()
+        }.groupBy { it.second::class }
+
+        val platforms = d.sourceSets
 
         fun DocumentableContentBuilder.contentForParams() {
             if (tags.isNotEmptyForTag<Param>()) {
-                val receiver = tags.withTypeUnnamed<Receiver>()
-                val params = tags.withTypeNamed<Param>()
-                platforms.forEach {
-                    header(4, "Parameters", kind = ContentKind.Parameters, platformData = setOf(it))
-                }
-                table(kind = ContentKind.Parameters) {
-                    platforms.flatMap { platform ->
-                        val receiverRow = receiver[platform]?.let {
-                            buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) {
-                                text("<receiver>", styles = mainStyles + ContentStyle.RowTitle)
-                                comment(it.root)
-                            }
-                        }
+                header(2, "Parameters")
+                group(extra = mainExtra + SimpleAttr.header("Parameters"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                    sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
+                        val receiver = tags.withTypeUnnamed<Receiver>()
+                        val params = tags.withTypeNamed<Param>()
+                        table(kind = ContentKind.Parameters) {
+                            platforms.flatMap { platform ->
+                                val receiverRow = receiver[platform]?.let {
+                                    buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) {
+                                        text("<receiver>", styles = mainStyles + ContentStyle.RowTitle)
+                                        comment(it.root)
+                                    }
+                                }
 
-                        val paramRows = params.mapNotNull { (_, param) ->
-                            param[platform]?.let {
-                                buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) {
-                                    text(it.name, kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.RowTitle)
-                                    comment(it.root)
+                                val paramRows = params.mapNotNull { (_, param) ->
+                                    param[platform]?.let {
+                                        buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) {
+                                            text(it.name, kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.RowTitle)
+                                            comment(it.root)
+                                        }
+                                    }
                                 }
+
+                                listOfNotNull(receiverRow) + paramRows
                             }
                         }
-
-                        listOfNotNull(receiverRow) + paramRows
                     }
                 }
             }
@@ -243,18 +281,20 @@ open class DefaultPageCreator(
 
         fun DocumentableContentBuilder.contentForSeeAlso() {
             if (tags.isNotEmptyForTag<See>()) {
-                val seeAlsoTags = tags.withTypeNamed<See>()
-                platforms.forEach {
-                    header(4, "See also", kind = ContentKind.Comment, platformData = setOf(it))
-                }
-                table(kind = ContentKind.Sample) {
-                    platforms.flatMap { platform ->
-                        seeAlsoTags.mapNotNull { (_, see) ->
-                            see[platform]?.let {
-                                buildGroup(sourceSets = setOf(platform), kind = ContentKind.Comment, styles = mainStyles + ContentStyle.RowTitle) {
-                                    if (it.address != null) link(it.name, it.address!!, kind = ContentKind.Comment)
-                                    else text(it.name, kind = ContentKind.Comment)
-                                    comment(it.root)
+                header(2, "See also")
+                group(extra = mainExtra + SimpleAttr.header("See also"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                    sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
+                        val seeAlsoTags = tags.withTypeNamed<See>()
+                        table(kind = ContentKind.Sample) {
+                            platforms.flatMap { platform ->
+                                seeAlsoTags.mapNotNull { (_, see) ->
+                                    see[platform]?.let {
+                                        buildGroup(sourceSets = setOf(platform), kind = ContentKind.Comment, styles = mainStyles + ContentStyle.RowTitle) {
+                                            if (it.address != null) link(it.name, it.address!!, kind = ContentKind.Comment)
+                                            else text(it.name, kind = ContentKind.Comment)
+                                            comment(it.root)
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -266,13 +306,17 @@ open class DefaultPageCreator(
         fun DocumentableContentBuilder.contentForSamples() {
             val samples = tags.withTypeNamed<Sample>()
             if (samples.isNotEmpty()) {
-                platforms.forEach { platformData ->
-                    val content = samples.filter { it.value.isEmpty() || platformData in it.value }
-                    if (content.isNotEmpty()) {
-                        group(sourceSets = setOf(platformData)) {
-                            header(4, "Samples", kind = ContentKind.Comment)
-                            content.forEach {
-                                comment(Text(it.key))
+                header(2, "Samples")
+                group(extra = mainExtra + SimpleAttr.header("Samples"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                    sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
+                        table(kind = ContentKind.Sample) {
+                            platforms.map { platformData ->
+                                val content = samples.filter { it.value.isEmpty() || platformData in it.value }
+                                buildGroup(sourceSets = setOf(platformData), styles = setOf(ContentStyle.RowTitle)) {
+                                    content.forEach {
+                                        comment(Text(it.key))
+                                    }
+                                }
                             }
                         }
                     }
@@ -280,32 +324,11 @@ open class DefaultPageCreator(
             }
         }
 
-        fun DocumentableContentBuilder.contentForUnnamedTags() {
-            val unnamedTags: List<SourceSetDependent<TagWrapper>> =
-                tags.filterNot { (k, _) -> k.isSubclassOf(NamedTagWrapper::class) || k in specialTags }
-                    .map { (_, v) -> v.mapNotNull { (k,v) -> k?.let { it to v } }.toMap() }
-            platforms.forEach { platform ->
-                unnamedTags.forEach { pdTag ->
-                    pdTag[platform]?.also { tag ->
-                        group(sourceSets = setOf(platform)) {
-                            header(4, tag.toHeaderString())
-                            comment(tag.root)
-                        }
-                    }
-                }
-            }
-        }
-
         return contentBuilder.contentFor(d) {
             if (tags.isNotEmpty()) {
-                header(3, "Description")
-                sourceSetDependentHint(sourceSets = platforms.toSet()) {
-                    contentForDescription()
-                    contentForSamples()
-                    contentForParams()
-                    contentForUnnamedTags()
-                    contentForSeeAlso()
-                }
+                contentForSamples()
+                contentForSeeAlso()
+                contentForParams()
             }
         }.children
     }
@@ -323,13 +346,16 @@ open class DefaultPageCreator(
     protected open fun contentForFunction(f: DFunction) = contentForMember(f)
     protected open fun contentForTypeAlias(t: DTypeAlias) = contentForMember(t)
     protected open fun contentForMember(d: Documentable) = contentBuilder.contentFor(d) {
-        header(1, d.name.orEmpty())
+        group(kind = ContentKind.Cover) {
+            header(1, d.name.orEmpty())
+        }
         divergentGroup(ContentDivergentGroup.GroupID("member")) {
             instance(setOf(d.dri), d.sourceSets.toSet()) {
                 divergent(kind = ContentKind.Symbol) {
                     +buildSignature(d)
                 }
                 after {
+                    +contentForDescription(d)
                     +contentForComments(d)
                 }
             }
@@ -339,11 +365,12 @@ open class DefaultPageCreator(
     protected open fun DocumentableContentBuilder.divergentBlock(
         name: String,
         collection: Collection<Documentable>,
-        kind: ContentKind
+        kind: ContentKind,
+        extra: PropertyContainer<ContentNode> = mainExtra,
     ) {
         if (collection.any()) {
             header(2, name)
-            table(kind) {
+            table(kind, extra = extra) {
                 collection.groupBy { it.name }.map { (elementName, elements) -> // This groupBy should probably use LocationProvider
                     buildGroup(elements.map { it.dri }.toSet(), elements.flatMap { it.sourceSets }.toSet(), kind = kind) {
                         link(elementName.orEmpty(), elements.first().dri, kind = kind)