| package org.jetbrains.dokka.Formats |
| |
| import com.google.inject.Inject |
| import com.google.inject.name.Named |
| import kotlinx.html.* |
| import org.jetbrains.dokka.* |
| import org.jetbrains.dokka.Samples.DevsiteSampleProcessingService |
| import org.jetbrains.dokka.Kotlin.ParameterInfoNode |
| import org.jetbrains.dokka.Utilities.firstSentence |
| import java.lang.Math.max |
| import java.net.URI |
| import kotlin.reflect.KClass |
| |
| /** |
| * On Devsite, certain headers and footers are needed for generating Devsite metadata. |
| */ |
| class DevsiteHtmlTemplateService @Inject constructor( |
| @Named("outlineRoot") val outlineRoot: String, |
| @Named("dacRoot") val dacRoot: String |
| ) : JavaLayoutHtmlTemplateService { |
| override fun composePage(page: JavaLayoutHtmlFormatOutputBuilder.Page, tagConsumer: TagConsumer<Appendable>, headContent: HEAD.() -> Unit, bodyContent: BODY.() -> Unit) { |
| tagConsumer.html { |
| attributes["devsite"] = "true" |
| head { |
| headContent() |
| title { |
| +when (page) { |
| is JavaLayoutHtmlFormatOutputBuilder.Page.ClassIndex -> "Class Index" |
| is JavaLayoutHtmlFormatOutputBuilder.Page.ClassPage -> page.node.nameWithOuterClass() |
| is JavaLayoutHtmlFormatOutputBuilder.Page.PackageIndex -> "Package Index" |
| is JavaLayoutHtmlFormatOutputBuilder.Page.PackagePage -> page.node.nameWithOuterClass() |
| } |
| } |
| unsafe { +"{% setvar book_path %}${dacRoot}/${outlineRoot}_book.yaml{% endsetvar %}\n{% include \"_shared/_reference-head-tags.html\" %}\n" } |
| } |
| body { |
| bodyContent() |
| } |
| } |
| } |
| } |
| |
| class DevsiteLayoutHtmlFormatOutputBuilderFactoryImpl @javax.inject.Inject constructor( |
| val uriProvider: JavaLayoutHtmlUriProvider, |
| val languageService: LanguageService, |
| val templateService: JavaLayoutHtmlTemplateService, |
| val logger: DokkaLogger |
| ) : JavaLayoutHtmlFormatOutputBuilderFactory { |
| override fun createOutputBuilder(output: Appendable, node: DocumentationNode): JavaLayoutHtmlFormatOutputBuilder { |
| return createOutputBuilder(output, uriProvider.mainUri(node)) |
| } |
| |
| override fun createOutputBuilder(output: Appendable, uri: URI): JavaLayoutHtmlFormatOutputBuilder { |
| return DevsiteLayoutHtmlFormatOutputBuilder(output, languageService, uriProvider, templateService, logger, uri) |
| } |
| } |
| |
| class DevsiteLayoutHtmlFormatOutputBuilder( |
| output: Appendable, |
| languageService: LanguageService, |
| uriProvider: JavaLayoutHtmlUriProvider, |
| templateService: JavaLayoutHtmlTemplateService, |
| logger: DokkaLogger, |
| uri: URI |
| ) : JavaLayoutHtmlFormatOutputBuilder(output, languageService, uriProvider, templateService, logger, uri) { |
| override fun FlowContent.fullMemberDocs(node: DocumentationNode) { |
| fullMemberDocs(node, node) |
| } |
| |
| override fun FlowContent.fullMemberDocs(node: DocumentationNode, uriNode: DocumentationNode) { |
| a { |
| attributes["name"] = uriNode.signatureForAnchor(logger).anchorEncoded() |
| } |
| div(classes = "api apilevel-${node.apiLevel.name}") { |
| attributes["data-version-added"] = node.apiLevel.name |
| h3(classes = "api-name") { |
| //id = node.signatureForAnchor(logger).urlEncoded() |
| +node.prettyName |
| } |
| apiAndDeprecatedVersions(node) |
| pre(classes = "api-signature no-pretty-print") { renderedSignature(node, LanguageService.RenderMode.FULL) } |
| deprecationWarningToMarkup(node, prefix = true) |
| nodeContent(node, uriNode) |
| node.constantValue()?.let { value -> |
| pre { |
| +"Value: " |
| code { +value } |
| } |
| } |
| for ((name, sections) in node.content.sections.groupBy { it.tag }) { |
| when (name) { |
| ContentTags.Return -> { |
| table(classes = "responsive") { |
| tbody { |
| tr { |
| th { |
| colSpan = "2" |
| +name |
| } |
| } |
| sections.forEach { |
| tr { |
| if (it.children.size > 0) { |
| td { |
| val firstChild = it.children.first() |
| if (firstChild is ContentBlock && |
| firstChild.children.size == 3 && |
| firstChild.children[0] is NodeRenderContent && |
| firstChild.children[1] is ContentSymbol && |
| firstChild.children[2] is ContentText) { |
| // it.children is expected to have two items |
| // First should have 3 children of its own: |
| // - NodeRenderContent is the return type |
| // - ContentSymbol - ":" |
| // - ContentText - " " |
| // We want to only use NodeRenderContent in a separate <td> and |
| // <code> to get proper formatting in DAC. |
| code { |
| metaMarkup(listOf(firstChild.children[0])) |
| } |
| } else { |
| metaMarkup(listOf(firstChild)) |
| } |
| } |
| td { |
| if (it.children.size > 1) { |
| metaMarkup(it.children.subList(1, it.children.size)) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| ContentTags.Parameters -> { |
| table(classes = "responsive") { |
| tbody { |
| tr { |
| th { |
| colSpan = "2" |
| +name |
| } |
| } |
| sections.forEach { section -> |
| tr { |
| td { |
| val parameterInfoNode = section.children.find { it is ParameterInfoNode } as? ParameterInfoNode |
| // If there is no info found, just display the parameter |
| // name. |
| if (parameterInfoNode?.parameterContent == null) { |
| code { |
| section.subjectName?.let { +it } |
| } |
| } else { |
| // Add already marked up type information here |
| metaMarkup( |
| listOf(parameterInfoNode.parameterContent!!) |
| ) |
| } |
| } |
| td { |
| metaMarkup(section.children) |
| } |
| } |
| } |
| } |
| } |
| } |
| ContentTags.SeeAlso -> { |
| div { |
| p { |
| b { |
| +name |
| } |
| } |
| ul(classes = "nolist") { |
| sections.filter {it.tag == "See Also"}.forEach { |
| it.children.forEach { child -> |
| if (child is ContentNodeLazyLink || child is ContentExternalLink) { |
| li { |
| code { |
| contentNodeToMarkup(child) // Wrap bare links in listItems. |
| } // bare links come from the java-to-kotlin parser. |
| } |
| } |
| else if (child is ContentUnorderedList) { |
| metaMarkup(child.children) // Already wrapped in listItems. |
| } // this is how we want things to look. No parser currently does this (yet). |
| else if (child is ContentParagraph) { |
| li{ |
| code { |
| metaMarkup (child.children) // Replace paragraphs with listItems. |
| } // paragraph-wrapped links come from the kotlin parser |
| } |
| } // NOTE: currently the java-to-java parser does not add See Also links! |
| } |
| } |
| } |
| } |
| } |
| ContentTags.Exceptions -> { |
| table(classes = "responsive") { |
| tbody { |
| tr { |
| th { |
| colSpan = "2" |
| +name |
| } |
| } |
| sections.forEach { |
| tr { |
| td { |
| code { |
| it.subjectName?.let { +it } |
| } |
| } |
| td { |
| metaMarkup(it.children) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| override fun summary(node: DocumentationNode) = node.firstSentenceOfSummary() |
| |
| fun TBODY.xmlAttributeRow(attr: DocumentationNode) = tr { |
| td { |
| a(href = attr) { |
| code { |
| +attr.attributeRef!!.name |
| } |
| } |
| } |
| td { |
| +attr.attributeRef!!.firstSentence() |
| } |
| } |
| |
| protected fun FlowContent.fullAttributeDocs( |
| attributes: List<DocumentationNode>, |
| header: String |
| ) { |
| if (attributes.none()) return |
| h2 { |
| +header |
| } |
| attributes.forEach { |
| fullMemberDocs(it.attributeRef!!, it) |
| } |
| } |
| |
| override fun FlowContent.classLikeFullMemberDocs(page: Page.ClassPage) = with(page) { |
| fullAttributeDocs(attributes, "XML attributes") |
| fullMemberDocs(enumValues, "Enum values") |
| fullMemberDocs(constants, "Constants") |
| |
| constructors.forEach { (visibility, group) -> |
| fullMemberDocs(group, "${visibility.capitalize()} constructors") |
| } |
| |
| functions.forEach { (visibility, group) -> |
| fullMemberDocs(group, "${visibility.capitalize()} methods") |
| } |
| |
| fullMemberDocs(properties, "Properties") |
| |
| fields.forEach { (visibility, group) -> |
| fullMemberDocs(group, "${visibility.capitalize()} fields") |
| } |
| if (!hasMeaningfulCompanion) { |
| fullMemberDocs(companionFunctions, "Companion functions") |
| fullMemberDocs(companionProperties, "Companion properties") |
| } |
| } |
| |
| override fun FlowContent.classLikeSummaries(page: Page.ClassPage) = with(page) { |
| summaryNodeGroup( |
| nestedClasses, |
| header = "Nested classes", |
| summaryId = "nestedclasses", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { |
| nestedClassSummaryRow(it) |
| } |
| |
| summaryNodeGroup( |
| attributes, |
| header="XML attributes", |
| summaryId="lattrs", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { |
| xmlAttributeRow(it) |
| } |
| |
| expandableSummaryNodeGroupForInheritedMembers( |
| superClasses = inheritedAttributes.entries, |
| header="Inherited XML attributes", |
| tableId="inhattrs", |
| tableClass = "responsive", |
| row = { inheritedXmlAttributeRow(it)} |
| ) |
| |
| summaryNodeGroup( |
| constants, |
| header = "Constants", |
| summaryId = "constants", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { propertyLikeSummaryRow(it) } |
| |
| expandableSummaryNodeGroupForInheritedMembers( |
| superClasses = inheritedConstants.entries, |
| header = "Inherited constants", |
| tableId = "inhconstants", |
| tableClass = "responsive constants inhtable", |
| row = { inheritedMemberRow(it) } |
| ) |
| |
| constructors.forEach { (visibility, group) -> |
| summaryNodeGroup( |
| group, |
| header = "${visibility.capitalize()} constructors", |
| summaryId = "${visibility.take(3)}ctors", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { |
| functionLikeSummaryRow(it) |
| } |
| } |
| |
| summaryNodeGroup( |
| enumValues, |
| header = "Enum values", |
| summaryId = "enumvalues", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { |
| propertyLikeSummaryRow(it, showSignature = false) |
| } |
| |
| functions.forEach { (visibility, group) -> |
| summaryNodeGroup( |
| group, |
| header = "${visibility.capitalize()} methods", |
| summaryId = "${visibility.take(3)}methods", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { |
| functionLikeSummaryRow(it) |
| } |
| } |
| |
| summaryNodeGroup( |
| companionFunctions, |
| header = "Companion functions", |
| summaryId = "compmethods", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { |
| functionLikeSummaryRow(it) |
| } |
| |
| expandableSummaryNodeGroupForInheritedMembers( |
| superClasses = inheritedFunctionsByReceiver.entries, |
| header = "Inherited functions", |
| tableId = "inhmethods", |
| tableClass = "responsive", |
| row = { inheritedMemberRow(it) } |
| ) |
| |
| summaryNodeGroup( |
| extensionFunctions.entries, |
| header = "Extension functions", |
| summaryId = "extmethods", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { |
| extensionRow(it) { |
| functionLikeSummaryRow(it) |
| } |
| } |
| summaryNodeGroup( |
| inheritedExtensionFunctions.entries, |
| header = "Inherited extension functions", |
| summaryId = "inhextmethods", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { |
| extensionRow(it) { |
| functionLikeSummaryRow(it) |
| } |
| } |
| |
| fields.forEach { (visibility, group) -> |
| summaryNodeGroup( |
| group, |
| header = "${visibility.capitalize()} fields", |
| summaryId = "${visibility.take(3)}fields", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { propertyLikeSummaryRow(it) } |
| } |
| |
| expandableSummaryNodeGroupForInheritedMembers( |
| superClasses = inheritedFieldsByReceiver.entries, |
| header = "Inherited fields", |
| tableId = "inhfields", |
| tableClass = "responsive properties inhtable", |
| row = { inheritedMemberRow(it) } |
| ) |
| |
| summaryNodeGroup( |
| properties, |
| header = "Properties", |
| summaryId = "properties", |
| tableClass = "responsive", |
| headerAsRow = true |
| ) { propertyLikeSummaryRow(it) } |
| |
| |
| summaryNodeGroup( |
| companionProperties, |
| "Companion properties", |
| headerAsRow = true |
| ) { |
| propertyLikeSummaryRow(it) |
| } |
| |
| expandableSummaryNodeGroupForInheritedMembers( |
| superClasses = inheritedPropertiesByReceiver.entries, |
| header = "Inherited properties", |
| tableId = "inhfields", |
| tableClass = "responsive properties inhtable", |
| row = { inheritedMemberRow(it) } |
| ) |
| |
| summaryNodeGroup( |
| extensionProperties.entries, |
| "Extension properties", |
| headerAsRow = true |
| ) { |
| extensionRow(it) { |
| propertyLikeSummaryRow(it) |
| } |
| } |
| |
| summaryNodeGroup( |
| inheritedExtensionProperties.entries, |
| "Inherited extension properties", |
| headerAsRow = true |
| ) { |
| extensionRow(it) { |
| propertyLikeSummaryRow(it) |
| } |
| } |
| } |
| |
| fun <T> FlowContent.summaryNodeGroup( |
| nodes: Iterable<T>, |
| header: String, |
| headerAsRow: Boolean, |
| summaryId: String, |
| tableClass: String = "responsive", |
| row: TBODY.(T) -> Unit |
| ) { |
| if (nodes.none()) return |
| if (!headerAsRow) { |
| h2 { +header } |
| } |
| table(classes = tableClass) { |
| id = summaryId |
| tbody { |
| if (headerAsRow) { |
| developerHeading(header) |
| } |
| nodes.forEach { node -> |
| row(node) |
| } |
| } |
| } |
| } |
| |
| override fun FlowContent.contentBlockCode(content: ContentBlockCode) { |
| pre { |
| attributes["class"] = "prettyprint" |
| contentNodesToMarkup(content.children) |
| } |
| } |
| |
| override fun FlowContent.contentBlockSampleCode(content: ContentBlockSampleCode) { |
| pre { |
| attributes["class"] = "prettyprint" |
| contentNodesToMarkup(content.importsBlock.children) |
| +"\n\n" |
| contentNodesToMarkup(content.children) |
| } |
| } |
| |
| override fun generatePackage(page: Page.PackagePage) = templateService.composePage( |
| page, |
| htmlConsumer, |
| headContent = { |
| |
| }, |
| bodyContent = { |
| h1 { +page.node.name } |
| nodeContent(page.node) |
| summaryNodeGroup(page.interfaces.sortedBy { it.nameWithOuterClass().toLowerCase() }, "Interfaces", headerAsRow = false) { classLikeRow(it) } |
| summaryNodeGroup(page.classes.sortedBy { it.nameWithOuterClass().toLowerCase() }, "Classes", headerAsRow = false) { classLikeRow(it) } |
| summaryNodeGroup(page.exceptions.sortedBy { it.nameWithOuterClass().toLowerCase() }, "Exceptions", headerAsRow = false) { classLikeRow(it) } |
| summaryNodeGroup(page.typeAliases.sortedBy { it.nameWithOuterClass().toLowerCase() }, "Type-aliases", headerAsRow = false) { classLikeRow(it) } |
| summaryNodeGroup(page.annotations.sortedBy { it.nameWithOuterClass().toLowerCase() }, "Annotations", headerAsRow = false) { classLikeRow(it) } |
| summaryNodeGroup(page.enums.sortedBy { it.nameWithOuterClass().toLowerCase() }, "Enums", headerAsRow = false) { classLikeRow(it) } |
| |
| summaryNodeGroup( |
| page.constants.sortedBy { it.name }, |
| "Top-level constants summary", |
| headerAsRow = false |
| ) { |
| propertyLikeSummaryRow(it) |
| } |
| |
| summaryNodeGroup( |
| page.functions.sortedBy { it.name }, |
| "Top-level functions summary", |
| headerAsRow = false |
| ) { |
| functionLikeSummaryRow(it) |
| } |
| |
| summaryNodeGroup( |
| page.properties.sortedBy { it.name }, |
| "Top-level properties summary", |
| headerAsRow = false |
| ) { |
| propertyLikeSummaryRow(it) |
| } |
| |
| summaryNodeGroupForExtensions("Extension functions summary", page.extensionFunctions.entries) |
| summaryNodeGroupForExtensions("Extension properties summary", page.extensionProperties.entries) |
| |
| fullMemberDocs(page.constants.sortedBy { it.name }, "Top-level constants") |
| fullMemberDocs(page.functions.sortedBy { it.name }, "Top-level functions") |
| fullMemberDocs(page.properties.sortedBy { it.name }, "Top-level properties") |
| fullMemberDocs(page.extensionFunctions.values.flatten().sortedBy { it.name }, "Extension functions") |
| fullMemberDocs(page.extensionProperties.values.flatten().sortedBy { it.name }, "Extension properties") |
| } |
| ) |
| |
| private fun TBODY.inheritedXmlAttributeRow(inheritedMember: DocumentationNode) { |
| tr(classes = "api apilevel-${inheritedMember.attributeRef!!.apiLevel.name}") { |
| attributes["data-version-added"] = "${inheritedMember.apiLevel}" |
| td { |
| code { |
| a(href = inheritedMember) { +inheritedMember.attributeRef!!.name } |
| } |
| } |
| td { |
| attributes["width"] = "100%" |
| p { |
| nodeContent(inheritedMember.attributeRef!!, inheritedMember) |
| } |
| } |
| } |
| } |
| |
| private fun TBODY.inheritedMemberRow(inheritedMember: DocumentationNode) { |
| tr(classes = "api apilevel-${inheritedMember.apiLevel.name}") { |
| attributes["data-version-added"] = "${inheritedMember.apiLevel}" |
| val type = inheritedMember.detailOrNull(NodeKind.Type) |
| td { |
| code { |
| type?.let { |
| renderedSignature(it, LanguageService.RenderMode.SUMMARY) |
| } |
| } |
| } |
| td { |
| attributes["width"] = "100%" |
| code { |
| a(href = inheritedMember) { +inheritedMember.name } |
| if (inheritedMember.kind == NodeKind.Function) { |
| shortFunctionParametersList(inheritedMember) |
| } |
| } |
| p { |
| nodeContent(inheritedMember) |
| } |
| } |
| } |
| } |
| |
| private fun FlowContent.expandableSummaryNodeGroupForInheritedMembers( |
| tableId: String, |
| header: String, |
| tableClass: String, |
| superClasses: Set<Map.Entry<DocumentationNode, List<DocumentationNode>>>, |
| row: TBODY.(inheritedMember: DocumentationNode) -> Unit |
| ) { |
| if (superClasses.none()) return |
| table(classes = tableClass) { |
| attributes["id"] = tableId |
| tbody { |
| developerHeading(header) |
| superClasses.forEach { (superClass, members) -> |
| tr(classes = "api apilevel-${superClass.apiLevel.name}") { |
| td { |
| attributes["colSpan"] = "2" |
| div(classes = "expandable jd-inherited-apis") { |
| span(classes = "expand-control exw-expanded") { |
| +"From class " |
| code { |
| a(href = superClass) { +superClass.name } |
| } |
| } |
| table(classes = "responsive exw-expanded-content") { |
| tbody { |
| members.forEach { inheritedMember -> |
| row(inheritedMember) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private fun FlowContent.summaryNodeGroupForExtensions( |
| header: String, |
| receivers: Set<Map.Entry<DocumentationNode, List<DocumentationNode>>> |
| ) { |
| if (receivers.none()) return |
| h2 { +header } |
| div { |
| receivers.forEach { |
| table { |
| tr { |
| td { |
| attributes["colSpan"] = "2" |
| +"For " |
| a(href = it.key) { +it.key.name } |
| } |
| } |
| it.value.forEach { node -> |
| tr { |
| if (node.kind != NodeKind.Constructor) { |
| td { |
| modifiers(node) |
| renderedSignature(node.detail(NodeKind.Type), LanguageService.RenderMode.SUMMARY) |
| } |
| } |
| td { |
| div { |
| code { |
| val receiver = node.detailOrNull(NodeKind.Receiver) |
| if (receiver != null) { |
| renderedSignature(receiver.detail(NodeKind.Type), LanguageService.RenderMode.SUMMARY) |
| +"." |
| } |
| a(href = node) { +node.name } |
| shortFunctionParametersList(node) |
| } |
| } |
| |
| nodeSummary(node) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| override fun generatePackageIndex(page: Page.PackageIndex) = templateService.composePage( |
| page, |
| htmlConsumer, |
| headContent = { |
| |
| }, |
| bodyContent = { |
| h1 { +"Package Index" } |
| table { |
| tbody { |
| for (node in page.packages) { |
| tr { |
| td { |
| a(href = uriProvider.linkTo(node, uri)) { +node.name } |
| } |
| } |
| } |
| } |
| } |
| } |
| ) |
| |
| override fun generateClassIndex(page: Page.ClassIndex) = templateService.composePage( |
| page, |
| htmlConsumer, |
| headContent = { |
| |
| }, |
| bodyContent = { |
| h1 { +"Class Index" } |
| |
| p { |
| +"These are all the API classes. See all " |
| a(href="packages.html") { |
| +"API packages." |
| } |
| } |
| |
| div(classes = "jd-letterlist") { |
| page.classesByFirstLetter.forEach { (letter) -> |
| +"\n " |
| a(href = "#letter_$letter") { +letter } |
| unsafe { |
| raw(" ") |
| } |
| } |
| +"\n " |
| } |
| |
| page.classesByFirstLetter.forEach { (letter, classes) -> |
| h2 { |
| id = "letter_$letter" |
| +letter |
| } |
| table { |
| tbody { |
| for (node in classes) { |
| tr { |
| td { |
| a(href = uriProvider.linkTo(node, uri)) { +node.classNodeNameWithOuterClass() } |
| } |
| td { |
| if (!deprecatedIndexSummary(node)) { |
| nodeSummary(node) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| ) |
| |
| override fun FlowContent.classHierarchy(superclasses: List<DocumentationNode>) { |
| table(classes = "jd-inheritance-table") { |
| var level = superclasses.size |
| superclasses.forEach { |
| tr { |
| var spaceColumns = max(superclasses.size - 1 - level, 0) |
| while (spaceColumns > 0) { |
| td(classes = "jd-inheritance-space") { |
| +" " |
| } |
| spaceColumns-- |
| } |
| if (it != superclasses.first()) { |
| td(classes = "jd-inheritance-space") { |
| +"   ↳" |
| } |
| } |
| td(classes = "jd-inheritance-class-cell") { |
| attributes["colSpan"] = "$level" |
| qualifiedTypeReference(it) |
| } |
| } |
| level-- |
| } |
| } |
| } |
| |
| override fun FlowContent.subclasses(inheritors: List<DocumentationNode>, direct: Boolean) { |
| if (inheritors.isEmpty()) return |
| |
| // The number of subclasses in collapsed view before truncating and adding a "and xx others". |
| // See https://developer.android.com/reference/android/view/View for an example. |
| val numToShow = 12 |
| |
| table(classes = "jd-sumtable jd-sumtable-subclasses") { |
| tbody { |
| tr { |
| td { |
| div(classes = "expandable") { |
| span(classes = "expand-control") { |
| if (direct) |
| +"Known Direct Subclasses" |
| else |
| +"Known Indirect Subclasses" |
| } |
| div(classes = "showalways") { |
| attributes["id"] = if (direct) "subclasses-direct" else "subclasses-indirect" |
| |
| inheritors.take(numToShow).forEach { inheritor -> |
| a(href = inheritor) { +inheritor.classNodeNameWithOuterClass() } |
| if (inheritor != inheritors.last()) +", " |
| } |
| |
| if (inheritors.size > numToShow) { |
| +"and ${inheritors.size - numToShow} others." |
| } |
| } |
| div(classes = "exw-expanded-content") { |
| attributes["id"] = if (direct) "subclasses-direct-summary" else "subclasses-indirect-summary" |
| table(classes = "jd-sumtable-expando") { |
| inheritors.forEach { inheritor -> |
| tr(classes = "api api-level-${inheritor.apiLevel.name}") { |
| attributes["data-version-added"] = inheritor.apiLevel.name |
| td(classes = "jd-linkcol") { |
| a(href = inheritor) { +inheritor.classNodeNameWithOuterClass() } |
| } |
| td(classes = "jd-descrcol") { |
| attributes["width"] = "100%" |
| nodeSummary(inheritor) |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| fun DocumentationNode.firstSentenceOfSummary(): ContentNode { |
| |
| fun Sequence<ContentNode>.flatten(): Sequence<ContentNode> { |
| return flatMap { |
| when (it) { |
| is ContentParagraph -> it.children.asSequence().flatten() |
| else -> sequenceOf(it) |
| } |
| } |
| } |
| |
| fun ContentNode.firstSentence(): ContentText? = when(this) { |
| is ContentText -> ContentText(text.firstSentence()) |
| else -> null |
| } |
| |
| val elements = sequenceOf(summary).flatten() |
| fun containsDot(it: ContentNode) = (it as? ContentText)?.text?.contains(".") == true |
| |
| val paragraph = ContentParagraph() |
| (elements.takeWhile { !containsDot(it) } + elements.firstOrNull { containsDot(it) }?.firstSentence()).forEach { |
| if (it != null) { |
| paragraph.append(it) |
| } |
| } |
| if (paragraph.isEmpty()) { |
| return ContentEmpty |
| } |
| |
| return paragraph |
| } |
| |
| fun DocumentationNode.firstSentence(): String { |
| val sb = StringBuilder() |
| addContentNodeToStringBuilder(content, sb) |
| return sb.toString().firstSentence() |
| } |
| |
| private fun addContentNodesToStringBuilder(content: List<ContentNode>, sb: StringBuilder): Unit = |
| content.forEach { addContentNodeToStringBuilder(it, sb) } |
| |
| private fun addContentNodeToStringBuilder(content: ContentNode, sb: StringBuilder) { |
| when (content) { |
| is ContentText -> sb.appendWith(content.text) |
| is ContentSymbol -> sb.appendWith(content.text) |
| is ContentKeyword -> sb.appendWith(content.text) |
| is ContentIdentifier -> sb.appendWith(content.text) |
| is ContentEntity -> sb.appendWith(content.text) |
| |
| is ContentHeading -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentStrong -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentStrikethrough -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentEmphasis -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentOrderedList -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentUnorderedList -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentListItem -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentCode -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentBlockSampleCode -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentBlockCode -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentParagraph -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentNodeLink -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentBookmark -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentExternalLink -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentLocalLink -> addContentNodesToStringBuilder(content.children, sb) |
| is ContentSection -> { } |
| is ContentBlock -> addContentNodesToStringBuilder(content.children, sb) |
| } |
| } |
| |
| private fun StringBuilder.appendWith(text: String, delimiter: String = " ") { |
| if (this.length == 0) { |
| append(text) |
| } else { |
| append(delimiter) |
| append(text) |
| } |
| } |
| } |
| |
| fun TBODY.developerHeading(header: String) { |
| tr { |
| th { |
| attributes["colSpan"] = "2" |
| +header |
| } |
| } |
| } |
| |
| class DacFormatDescriptor : JavaLayoutHtmlFormatDescriptorBase(), DefaultAnalysisComponentServices by KotlinAsKotlin { |
| override val templateServiceClass: KClass<out JavaLayoutHtmlTemplateService> = DevsiteHtmlTemplateService::class |
| |
| override val outlineFactoryClass = DacOutlineFormatter::class |
| override val languageServiceClass = KotlinLanguageService::class |
| override val packageListServiceClass: KClass<out PackageListService> = JavaLayoutHtmlPackageListService::class |
| override val outputBuilderFactoryClass: KClass<out JavaLayoutHtmlFormatOutputBuilderFactory> = DevsiteLayoutHtmlFormatOutputBuilderFactoryImpl::class |
| override val sampleProcessingService = DevsiteSampleProcessingService::class |
| } |
| |
| |
| class DacAsJavaFormatDescriptor : JavaLayoutHtmlFormatDescriptorBase(), DefaultAnalysisComponentServices by KotlinAsJava { |
| override val templateServiceClass: KClass<out JavaLayoutHtmlTemplateService> = DevsiteHtmlTemplateService::class |
| |
| override val outlineFactoryClass = DacOutlineFormatter::class |
| override val languageServiceClass = NewJavaLanguageService::class |
| override val packageListServiceClass: KClass<out PackageListService> = JavaLayoutHtmlPackageListService::class |
| override val outputBuilderFactoryClass: KClass<out JavaLayoutHtmlFormatOutputBuilderFactory> = DevsiteLayoutHtmlFormatOutputBuilderFactoryImpl::class |
| } |
