From 899c11d36f565cd192945573860568ff62c16ef2 Mon Sep 17 00:00:00 2001 From: aleksZubakov Date: Wed, 25 Jul 2018 17:24:00 +0300 Subject: Add logic of merging different platforms graphs --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index ebc9cde6..41c8f29a 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -514,15 +514,15 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendSection("Exceptions", node.membersOrGroupMembers(NodeKind.Exception)) appendSection("Type Aliases", node.membersOrGroupMembers(NodeKind.TypeAlias)) appendSection("Extensions for External Classes", node.members(NodeKind.ExternalClass)) - appendSection("Enum Values", node.members(NodeKind.EnumItem), sortMembers = false, omitSamePlatforms = true) - appendSection("Constructors", node.members(NodeKind.Constructor), omitSamePlatforms = true) - appendSection("Properties", node.members(NodeKind.Property), omitSamePlatforms = true) + appendSection("Enum Values", node.membersOrGroupMembers(NodeKind.EnumItem), sortMembers = false, omitSamePlatforms = true) + appendSection("Constructors", node.membersOrGroupMembers(NodeKind.Constructor), omitSamePlatforms = true) + appendSection("Properties", node.membersOrGroupMembers(NodeKind.Property), omitSamePlatforms = true) appendSection("Inherited Properties", node.inheritedMembers(NodeKind.Property)) - appendSection("Functions", node.members(NodeKind.Function), omitSamePlatforms = true) + appendSection("Functions", node.membersOrGroupMembers(NodeKind.Function), omitSamePlatforms = true) appendSection("Inherited Functions", node.inheritedMembers(NodeKind.Function)) - appendSection("Companion Object Properties", node.members(NodeKind.CompanionObjectProperty), omitSamePlatforms = true) + appendSection("Companion Object Properties", node.membersOrGroupMembers(NodeKind.CompanionObjectProperty), omitSamePlatforms = true) appendSection("Inherited Companion Object Properties", node.inheritedCompanionObjectMembers(NodeKind.Property)) - appendSection("Companion Object Functions", node.members(NodeKind.CompanionObjectFunction), omitSamePlatforms = true) + appendSection("Companion Object Functions", node.membersOrGroupMembers(NodeKind.CompanionObjectFunction), omitSamePlatforms = true) appendSection("Inherited Companion Object Functions", node.inheritedCompanionObjectMembers(NodeKind.Function)) appendSection("Other members", node.members.filter { it.kind !in setOf( -- cgit From 4456ead8b702e4881321488969cb4ce1711e5663 Mon Sep 17 00:00:00 2001 From: aleksZubakov Date: Mon, 6 Aug 2018 17:14:28 +0300 Subject: Optional dependency bug workaround: google/guice#847 --- core/src/main/kotlin/Formats/FormatDescriptor.kt | 1 + core/src/main/kotlin/Generation/FileGenerator.kt | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/FormatDescriptor.kt b/core/src/main/kotlin/Formats/FormatDescriptor.kt index b497fb0f..4bac8aa0 100644 --- a/core/src/main/kotlin/Formats/FormatDescriptor.kt +++ b/core/src/main/kotlin/Formats/FormatDescriptor.kt @@ -25,6 +25,7 @@ abstract class FileGeneratorBasedFormatDescriptor : FormatDescriptor { override fun configureOutput(binder: Binder): Unit = with(binder) { bind() toType NodeLocationAwareGenerator::class bind() toType generatorServiceClass + bind(generatorServiceClass.java) // https://github.com/google/guice/issues/847 bind() toType languageServiceClass diff --git a/core/src/main/kotlin/Generation/FileGenerator.kt b/core/src/main/kotlin/Generation/FileGenerator.kt index d7b35581..eb6800b3 100644 --- a/core/src/main/kotlin/Generation/FileGenerator.kt +++ b/core/src/main/kotlin/Generation/FileGenerator.kt @@ -10,7 +10,7 @@ import java.io.OutputStreamWriter class FileGenerator @Inject constructor(@Named("outputDir") override val root: File) : NodeLocationAwareGenerator { @set:Inject(optional = true) var outlineService: OutlineFormatService? = null - @set:Inject lateinit var formatService: FormatService + @set:Inject(optional = true) lateinit var formatService: FormatService @set:Inject(optional = true) lateinit var dokkaConfiguration: DokkaConfiguration @set:Inject(optional = true) var packageListService: PackageListService? = null -- cgit From 1f45cac76a79abb6eaad99b541234cbf34fbce9c Mon Sep 17 00:00:00 2001 From: Zubakov Aleksey Date: Fri, 17 Aug 2018 13:00:06 +0300 Subject: Merger platforms bug fix, refactoring --- .../main/kotlin/Formats/StructuredFormatService.kt | 2 + .../main/kotlin/Generation/DocumentationMerger.kt | 58 ++++++++-------------- core/src/main/kotlin/Generation/DokkaGenerator.kt | 19 +------ .../src/main/kotlin/Kotlin/DocumentationBuilder.kt | 23 ++++++--- 4 files changed, 42 insertions(+), 60 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 41c8f29a..b810dfca 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -404,6 +404,8 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, fun String.isKotlinVersion() = this.startsWith("Kotlin") + if (platforms.count() == 0) return emptySet() + // Calculating common platforms for items return platforms.reduce { result, platformsOfItem -> val otherKotlinVersion = result.find { it.isKotlinVersion() } diff --git a/core/src/main/kotlin/Generation/DocumentationMerger.kt b/core/src/main/kotlin/Generation/DocumentationMerger.kt index c2089821..c4a40df6 100644 --- a/core/src/main/kotlin/Generation/DocumentationMerger.kt +++ b/core/src/main/kotlin/Generation/DocumentationMerger.kt @@ -22,7 +22,6 @@ class DocumentationMerger( producedNodeRefGraph = NodeReferenceGraph() documentationModules.map { it.nodeRefGraph } .flatMap { it.references } - .distinct() .forEach { producedNodeRefGraph.addReference(it) } } @@ -30,7 +29,6 @@ class DocumentationMerger( from: DocumentationNode, packages: List ): List { - val packagesByName = packages .map { it.to } .groupBy { it.name } @@ -63,11 +61,13 @@ class DocumentationMerger( } oldToNewNodeMap[packageNode] = mergedPackage } - mergedPackage.clear() val references = packages.flatMap { it.allReferences() } val mergedReferences = mergeReferences(mergedPackage, references) - for (ref in mergedReferences.distinct()) { + for (ref in mergedReferences) { + if (ref.kind == RefKind.Owner) { + continue + } mergedPackage.addReference(ref) } @@ -76,8 +76,6 @@ class DocumentationMerger( return mergedPackage } - private fun DocumentationNode.clear() = dropReferences { true } - private fun mergeMembers( from: DocumentationNode, refs: List @@ -106,24 +104,17 @@ class DocumentationMerger( ): DocumentationNode { val singleNode = refs.singleOrNull() if (singleNode != null) { - singleNode.owner?.let { owner -> - singleNode.dropReferences { it.to == owner && it.kind == RefKind.Owner } - } + singleNode.dropReferences { it.kind == RefKind.Owner } return singleNode } val groupNode = DocumentationNode(refs.first().name, Content.Empty, NodeKind.GroupNode) groupNode.appendTextNode(signature, NodeKind.Signature, RefKind.Detail) for (node in refs) { - if (node != groupNode) { - node.owner?.let { owner -> - node.dropReferences { it.to == owner && it.kind == RefKind.Owner } - from.dropReferences { it.to == node && it.kind == RefKind.Member } - } - groupNode.append(node, RefKind.Member) + node.dropReferences { it.kind == RefKind.Owner } + groupNode.append(node, RefKind.Member) - oldToNewNodeMap[node] = groupNode - } + oldToNewNodeMap[node] = groupNode } return groupNode } @@ -140,25 +131,7 @@ class DocumentationMerger( val mergedMembers = mergeMembers(from, refsToMembers) // TODO: think about - return mergedPackages + (mergedMembers + refsNotToMembers).distinctBy { - it.to.kind to it.to.name - } - } - - - private fun updatePendingReferences() { - producedNodeRefGraph.references.forEach { - it.lazyNodeFrom.update() - it.lazyNodeTo.update() - } - } - - private fun NodeResolver.update() { - if (this is NodeResolver.Exact) { - if (exactNode != null && oldToNewNodeMap.containsKey(exactNode!!)) { - exactNode = oldToNewNodeMap[exactNode!!] - } - } + return mergedPackages + mergedMembers + refsNotToMembers } fun merge(): DocumentationModule { @@ -175,5 +148,18 @@ class DocumentationMerger( return mergedDocumentationModule } + private fun updatePendingReferences() { + for (ref in producedNodeRefGraph.references) { + ref.lazyNodeFrom.update() + ref.lazyNodeTo.update() + } + } + private fun NodeResolver.update() { + if (this is NodeResolver.Exact) { + if (exactNode != null && exactNode!! in oldToNewNodeMap) { + exactNode = oldToNewNodeMap[exactNode!!] + } + } + } } \ No newline at end of file diff --git a/core/src/main/kotlin/Generation/DokkaGenerator.kt b/core/src/main/kotlin/Generation/DokkaGenerator.kt index 37f62ed6..1193657e 100644 --- a/core/src/main/kotlin/Generation/DokkaGenerator.kt +++ b/core/src/main/kotlin/Generation/DokkaGenerator.kt @@ -69,13 +69,13 @@ class DokkaGenerator(val dokkaConfiguration: DokkaConfiguration, logger.info("Analysing sources and libraries... ") val startAnalyse = System.currentTimeMillis() - val defaultPlatformAsList = listOf(passConfiguration.analysisPlatform.key) + val defaultPlatformAsList = passConfiguration.targets val defaultPlatformsProvider = object : DefaultPlatformsProvider { override fun getDefaultPlatforms(descriptor: DeclarationDescriptor): List { val containingFilePath = descriptor.sourcePsi()?.containingFile?.virtualFile?.canonicalPath ?.let { File(it).absolutePath } val sourceRoot = containingFilePath?.let { path -> sourceRoots.find { path.startsWith(it.path) } } - return sourceRoot?.platforms ?: defaultPlatformAsList + return /*sourceRoot?.platforms ?: */defaultPlatformAsList } } @@ -83,12 +83,6 @@ class DokkaGenerator(val dokkaConfiguration: DokkaConfiguration, DokkaAnalysisModule(environment, dokkaConfiguration, defaultPlatformsProvider, documentationModule.nodeRefGraph, passConfiguration, logger)) buildDocumentationModule(injector, documentationModule, { isNotSample(it, passConfiguration.samples) }, includes) - documentationModule.visit { it -> - it.addReferenceTo( - DocumentationNode(analysisPlatform.key, Content.Empty, NodeKind.Platform), - RefKind.Platform - ) - } val timeAnalyse = System.currentTimeMillis() - startAnalyse logger.info("done in ${timeAnalyse / 1000} secs") @@ -96,15 +90,6 @@ class DokkaGenerator(val dokkaConfiguration: DokkaConfiguration, Disposer.dispose(environment) } - private fun DocumentationNode.visit(action: (DocumentationNode) -> Unit) { - action(this) - - for (member in members) { - member.visit(action) - } - } - - fun createAnalysisEnvironment( sourcePaths: List, passConfiguration: DokkaConfiguration.PassConfiguration diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt index be3eef71..c25a7069 100644 --- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt +++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt @@ -889,23 +889,27 @@ class DocumentationBuilder } - fun DocumentationNode.getParentForPackageMember(descriptor: DeclarationDescriptor, - externalClassNodes: MutableMap, - allFqNames: Collection): DocumentationNode { + fun DocumentationNode.getParentForPackageMember( + descriptor: DeclarationDescriptor, + externalClassNodes: MutableMap, + allFqNames: Collection, + packageName: FqName + ): DocumentationNode { if (descriptor is CallableMemberDescriptor) { val extensionClassDescriptor = descriptor.getExtensionClassDescriptor() if (extensionClassDescriptor != null && isExtensionForExternalClass(descriptor, extensionClassDescriptor, allFqNames) && !ErrorUtils.isError(extensionClassDescriptor)) { val fqName = DescriptorUtils.getFqNameSafe(extensionClassDescriptor) - return externalClassNodes.getOrPut(fqName, { + return externalClassNodes.getOrPut(fqName) { val newNode = DocumentationNode(fqName.asString(), Content.Empty, NodeKind.ExternalClass) val externalLink = linkResolver.externalDocumentationLinkResolver.buildExternalDocumentationLink(extensionClassDescriptor) if (externalLink != null) { newNode.append(DocumentationNode(externalLink, Content.Empty, NodeKind.ExternalLink), RefKind.Link) } append(newNode, RefKind.Member) + refGraph.register("${packageName.asString()}:${extensionClassDescriptor.signature()}", newNode) newNode - }) + } } } return this @@ -933,7 +937,12 @@ class KotlinPackageDocumentationBuilder : PackageDocumentationBuilder { declarations.forEach { descriptor -> with(documentationBuilder) { if (descriptor.isDocumented(passConfiguration)) { - val parent = packageNode.getParentForPackageMember(descriptor, externalClassNodes, allFqNames) + val parent = packageNode.getParentForPackageMember( + descriptor, + externalClassNodes, + allFqNames, + packageName + ) parent.appendOrUpdateMember(descriptor) } } @@ -1025,7 +1034,7 @@ fun DeclarationDescriptor.signature(): String { is TypeAliasDescriptor -> DescriptorUtils.getFqName(this).asString() is PropertyDescriptor -> containingDeclaration.signature() + "$" + name + receiverSignature() - is FunctionDescriptor -> containingDeclaration.signature() + "$" + name + parameterSignature() + ":" + returnType?.signature() + is FunctionDescriptor -> containingDeclaration.signature() + "$" + name + parameterSignature() + ":" + returnType?.signature() is ValueParameterDescriptor -> containingDeclaration.signature() + "/" + name is TypeParameterDescriptor -> containingDeclaration.signature() + "*" + name is ReceiverParameterDescriptor -> containingDeclaration.signature() + "/" + name -- cgit From 0b43db4ff81746e44d06780d8d14bb49dc1d87aa Mon Sep 17 00:00:00 2001 From: Zubakov Date: Mon, 27 Aug 2018 16:27:41 +0300 Subject: Introduce origin reference kind, change documentation graph merge logic, minor refactoring --- .../main/kotlin/Formats/StructuredFormatService.kt | 28 +++++----- .../main/kotlin/Generation/DocumentationMerger.kt | 65 +++++++++++++--------- .../src/main/kotlin/Kotlin/DocumentationBuilder.kt | 2 +- core/src/main/kotlin/Model/DocumentationNode.kt | 4 ++ .../main/kotlin/Model/DocumentationReference.kt | 5 +- 5 files changed, 61 insertions(+), 43 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index b810dfca..1ca636ec 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -192,22 +192,20 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } - open fun link(from: DocumentationNode, - to: DocumentationNode, - name: (DocumentationNode) -> String = DocumentationNode::name): FormatLink = link(from, to, extension, name) + open fun link( + from: DocumentationNode, + to: DocumentationNode, + name: (DocumentationNode) -> String = DocumentationNode::name + ): FormatLink = link(from, to, extension, name) + + open fun link( + from: DocumentationNode, + to: DocumentationNode, + extension: String, + name: (DocumentationNode) -> String = DocumentationNode::name + ): FormatLink = + FormatLink(name(to), from.location().relativePathTo(to.location())) - open fun link(from: DocumentationNode, - to: DocumentationNode, - extension: String, - name: (DocumentationNode) -> String = DocumentationNode::name): FormatLink { - if (to.owner?.kind == NodeKind.GroupNode) - return link(from, to.owner!!, extension, name) - - if (from.owner?.kind == NodeKind.GroupNode) - return link(from.owner!!, to, extension, name) - - return FormatLink(name(to), from.location().relativePathTo(to.location())) - } fun locationHref(from: Location, to: DocumentationNode): String { val topLevelPage = to.references(RefKind.TopLevelPage).singleOrNull()?.to diff --git a/core/src/main/kotlin/Generation/DocumentationMerger.kt b/core/src/main/kotlin/Generation/DocumentationMerger.kt index c4a40df6..0394dce2 100644 --- a/core/src/main/kotlin/Generation/DocumentationMerger.kt +++ b/core/src/main/kotlin/Generation/DocumentationMerger.kt @@ -5,7 +5,7 @@ import org.jetbrains.dokka.* class DocumentationMerger( private val documentationModules: List ) { - private val producedNodeRefGraph: NodeReferenceGraph + private val producedNodeRefGraph: NodeReferenceGraph = NodeReferenceGraph() private val signatureMap: Map private val oldToNewNodeMap: MutableMap = mutableMapOf() @@ -19,7 +19,6 @@ class DocumentationMerger( .associate { (k, v) -> v to k } - producedNodeRefGraph = NodeReferenceGraph() documentationModules.map { it.nodeRefGraph } .flatMap { it.references } .forEach { producedNodeRefGraph.addReference(it) } @@ -33,17 +32,17 @@ class DocumentationMerger( .map { it.to } .groupBy { it.name } - val mutableList = mutableListOf() + val resultReferences = mutableListOf() for ((name, listOfPackages) in packagesByName) { val producedPackage = mergePackagesWithEqualNames(name, from, listOfPackages) updatePendingReferences() - mutableList.add( + resultReferences.add( DocumentationReference(from, producedPackage, RefKind.Member) ) } - return mutableList + return resultReferences } private fun mergePackagesWithEqualNames( @@ -52,14 +51,17 @@ class DocumentationMerger( packages: List ): DocumentationNode { val mergedPackage = DocumentationNode(name, Content.Empty, NodeKind.Package) - for (packageNode in packages) { - // TODO: Discuss + + for (contentToAppend in packages.map { it.content }.distinct()) { mergedPackage.updateContent { - for (otherChild in packageNode.content.children) { + for (otherChild in contentToAppend.children) { children.add(otherChild) } } - oldToNewNodeMap[packageNode] = mergedPackage + } + + for (node in packages) { + oldToNewNodeMap[node] = mergedPackage } val references = packages.flatMap { it.allReferences() } @@ -76,7 +78,7 @@ class DocumentationMerger( return mergedPackage } - private fun mergeMembers( + private fun mergeMemberReferences( from: DocumentationNode, refs: List ): List { @@ -85,7 +87,7 @@ class DocumentationMerger( val mergedMembers: MutableList = mutableListOf() for ((signature, members) in membersBySignature) { - val newNode = mergeMembersWithEqualSignature(signature, from, members) + val newNode = mergeMembersWithEqualSignature(signature, members) producedNodeRefGraph.register(signature, newNode) updatePendingReferences() @@ -99,23 +101,39 @@ class DocumentationMerger( private fun mergeMembersWithEqualSignature( signature: String, - from: DocumentationNode, - refs: List + nodes: List ): DocumentationNode { - val singleNode = refs.singleOrNull() + val singleNode = nodes.singleOrNull() if (singleNode != null) { singleNode.dropReferences { it.kind == RefKind.Owner } return singleNode } - val groupNode = DocumentationNode(refs.first().name, Content.Empty, NodeKind.GroupNode) + + val groupNode = DocumentationNode(nodes.first().name, Content.Empty, NodeKind.GroupNode) groupNode.appendTextNode(signature, NodeKind.Signature, RefKind.Detail) - for (node in refs) { + for (node in nodes) { node.dropReferences { it.kind == RefKind.Owner } - groupNode.append(node, RefKind.Member) + groupNode.append(node, RefKind.Origin) oldToNewNodeMap[node] = groupNode } + + // if nodes are classes, nested members should be also merged and + // inserted at the same level with class + if (nodes.all { it.kind == NodeKind.Class }) { + val members = nodes.flatMap { it.allReferences() }.filter { it.kind == RefKind.Member } + val mergedMembers = mergeMemberReferences(groupNode, members) + + for (ref in mergedMembers) { + if (ref.kind == RefKind.Owner) { + continue + } + + groupNode.append(ref.to, RefKind.Member) + } + } + return groupNode } @@ -124,13 +142,12 @@ class DocumentationMerger( from: DocumentationNode, refs: List ): List { - val (refsToPackages, usualRefs) = refs.partition { it.to.kind == NodeKind.Package } + val (refsToPackages, otherRefs) = refs.partition { it.to.kind == NodeKind.Package } val mergedPackages = mergePackageReferences(from, refsToPackages) - val (refsToMembers, refsNotToMembers) = usualRefs.partition { it.kind == RefKind.Member } - val mergedMembers = mergeMembers(from, refsToMembers) + val (refsToMembers, refsNotToMembers) = otherRefs.partition { it.kind == RefKind.Member } + val mergedMembers = mergeMemberReferences(from, refsToMembers) - // TODO: think about return mergedPackages + mergedMembers + refsNotToMembers } @@ -156,10 +173,8 @@ class DocumentationMerger( } private fun NodeResolver.update() { - if (this is NodeResolver.Exact) { - if (exactNode != null && exactNode!! in oldToNewNodeMap) { - exactNode = oldToNewNodeMap[exactNode!!] - } + if (this is NodeResolver.Exact && exactNode in oldToNewNodeMap) { + exactNode = oldToNewNodeMap[exactNode]!! } } } \ No newline at end of file diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt index c25a7069..e5bc32ab 100644 --- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt +++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt @@ -1106,7 +1106,7 @@ fun DocumentationNode.generateAllTypesNode() { val allTypes = members(NodeKind.Package) .flatMap { it.members.filter { it.kind in NodeKind.classLike || it.kind == NodeKind.ExternalClass - || (it.kind == NodeKind.GroupNode && it.members.all { it.kind in NodeKind.classLike }) } } + || (it.kind == NodeKind.GroupNode && it.origins.all { it.kind in NodeKind.classLike }) } } .sortedBy { if (it.kind == NodeKind.ExternalClass) it.name.substringAfterLast('.').toLowerCase() else it.name.toLowerCase() } val allTypesNode = DocumentationNode("alltypes", Content.Empty, NodeKind.AllTypes) diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt index 23137364..146c1e99 100644 --- a/core/src/main/kotlin/Model/DocumentationNode.kt +++ b/core/src/main/kotlin/Model/DocumentationNode.kt @@ -84,6 +84,9 @@ open class DocumentationNode(val name: String, get() = references(RefKind.Detail).map { it.to } val members: List get() = references(RefKind.Member).map { it.to } + val origins: List + get() = references(RefKind.Origin).map { it.to } + val inheritedMembers: List get() = references(RefKind.InheritedMember).map { it.to } val allInheritedMembers: List @@ -203,6 +206,7 @@ fun DocumentationNode.append(child: DocumentationNode, kind: RefKind) { RefKind.Detail -> child.addReferenceTo(this, RefKind.Owner) RefKind.Member -> child.addReferenceTo(this, RefKind.Owner) RefKind.Owner -> child.addReferenceTo(this, RefKind.Member) + RefKind.Origin -> child.addReferenceTo(this, RefKind.Owner) else -> { /* Do not add any links back for other types */ } } diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt index 282d87d8..e10796d2 100644 --- a/core/src/main/kotlin/Model/DocumentationReference.kt +++ b/core/src/main/kotlin/Model/DocumentationReference.kt @@ -19,7 +19,8 @@ enum class RefKind { Deprecation, TopLevelPage, Platform, - ExternalType + ExternalType, + Origin } data class DocumentationReference(val from: DocumentationNode, val to: DocumentationNode, val kind: RefKind) { @@ -33,7 +34,7 @@ sealed class NodeResolver { } } - class Exact(var exactNode: DocumentationNode?) : NodeResolver() { + class Exact(var exactNode: DocumentationNode) : NodeResolver() { override fun resolve(nodeRephGraph: NodeReferenceGraph): DocumentationNode? { return exactNode } -- cgit From f7975495c64333cdf625dd970254cca2b796d576 Mon Sep 17 00:00:00 2001 From: Zubakov Date: Mon, 27 Aug 2018 16:35:47 +0300 Subject: TODO: remove unnecessary code block --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 1 + 1 file changed, 1 insertion(+) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 1ca636ec..1d201677 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -329,6 +329,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } // All items have exactly the same documentation, so we can use any item to render it val item = items.first() + // TODO: remove this block cause there is no one node with OverloadGroupNote detail item.details(NodeKind.OverloadGroupNote).forEach { appendContent(it.content) } -- cgit From 6034c10de4f208484485e6a53daa48cf11800ef5 Mon Sep 17 00:00:00 2001 From: Zubakov Date: Mon, 27 Aug 2018 19:57:34 +0300 Subject: Change render for kotlin mpp signatures rendering --- .../main/kotlin/Formats/StructuredFormatService.kt | 244 +++++++++++++++------ .../main/kotlin/Kotlin/KotlinLanguageService.kt | 2 +- 2 files changed, 173 insertions(+), 73 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 1d201677..b57f21be 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -296,7 +296,12 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } private fun appendDocumentation(overloads: Iterable, isSingleNode: Boolean) { - val breakdownBySummary = overloads.groupByTo(LinkedHashMap()) { node -> node.content } + val breakdownBySummary = overloads.groupByTo(LinkedHashMap()) { node -> + when (node.kind) { + NodeKind.GroupNode -> node.origins.first().content + else -> node.content + } + } if (breakdownBySummary.size == 1) { formatOverloadGroup(breakdownBySummary.values.single(), isSingleNode) @@ -314,18 +319,13 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, private fun formatOverloadGroup(items: List, isSingleNode: Boolean = false) { for ((index, item) in items.withIndex()) { if (index > 0) appendLine() - val rendered = languageService.render(item) - item.detailOrNull(NodeKind.Signature)?.let { - if (item.kind !in NodeKind.classLike || !isSingleNode) - appendAnchor(it.name) - } - appendAsSignature(rendered) { - appendCode { appendContent(rendered) } - item.appendSourceLink() + + if (item.kind == NodeKind.GroupNode) { + renderGroupNode(item, isSingleNode) + } else { + renderSimpleNode(item, isSingleNode) } - item.appendOverrides() - item.appendDeprecation() - item.appendPlatforms() + } // All items have exactly the same documentation, so we can use any item to render it val item = items.first() @@ -334,10 +334,75 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendContent(it.content) } - appendContent(item.content.summary) + if (item.kind == NodeKind.GroupNode) { + for (origin in item.origins) { + if (origin.content.isEmpty()) continue + appendParagraph { + appendStrong { to.append("Platform and version requirements:") } + to.append(" " + origin.actualPlatforms) + appendContent(origin.summary) + } + } + } else { + if (!item.content.isEmpty()) { + appendStrong { to.append("Platform and version requirements:") } + to.append(" " + item.actualPlatforms) + appendContent(item.content.summary) + } + } + item.appendDescription() } + + fun renderSimpleNode(item: DocumentationNode, isSingleNode: Boolean) { + // TODO: use summarizesignatures + val rendered = languageService.render(item) + item.detailOrNull(NodeKind.Signature)?.let { + if (item.kind !in NodeKind.classLike || !isSingleNode) + appendAnchor(it.name) + } + appendAsSignature(rendered) { + appendCode { appendContent(rendered) } + item.appendSourceLink() + } + item.appendOverrides() + item.appendDeprecation() + item.appendPlatforms() + } + + fun renderGroupNode(item: DocumentationNode, isSingleNode: Boolean) { + // TODO: use summarizesignatures + val groupBySignature = item.origins.groupBy { + languageService.render(it) + } + + for ((sign, nodes) in groupBySignature) { + val first = nodes.first() + first.detailOrNull(NodeKind.Signature)?.let { + if (item.kind !in NodeKind.classLike || !isSingleNode) + appendAnchor(it.name) + } + + appendAsSignature(sign) { + appendCode { appendContent(sign) } + } + first.appendOverrides() + first.appendDeprecation() + + + appendParagraph { + appendStrong { to.append("Platform and version requirements:") } + to.append(" " + nodes + .flatMap { it.actualPlatforms } + .distinct() + .joinToString() + ) + } + + } + } + private fun DocumentationNode.appendSourceLink() { val sourceUrl = details(NodeKind.SourceUrl).firstOrNull() if (sourceUrl != null) { @@ -362,29 +427,29 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, val deprecationParameter = deprecation!!.details(NodeKind.Parameter).firstOrNull() val deprecationValue = deprecationParameter?.details(NodeKind.Value)?.firstOrNull() appendLine() - if (deprecationValue != null) { - appendStrong { to.append("Deprecated:") } - appendText(" " + deprecationValue.name.removeSurrounding("\"")) - appendLine() - appendLine() - } else if (deprecation?.content != Content.Empty) { - appendStrong { to.append("Deprecated:") } - to.append(" ") - appendContent(deprecation!!.content) - } else { - appendStrong { to.append("Deprecated") } - appendLine() - appendLine() + when { + deprecationValue != null -> { + appendStrong { to.append("Deprecated:") } + appendText(" " + deprecationValue.name.removeSurrounding("\"")) + appendLine() + appendLine() + } + deprecation?.content != Content.Empty -> { + appendStrong { to.append("Deprecated:") } + to.append(" ") + appendContent(deprecation!!.content) + } + else -> { + appendStrong { to.append("Deprecated") } + appendLine() + appendLine() + } } } } private fun DocumentationNode.appendPlatforms() { - val platforms = if (isModuleOrPackage()) - platformsToShow.toSet() + platformsOfItems(members) - else - platformsToShow - + val platforms = actualPlatforms if (platforms.isEmpty()) return appendParagraph { @@ -393,10 +458,19 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } + val DocumentationNode.actualPlatforms: Collection + get() = if (isModuleOrPackage()) + platformsToShow.toSet() + platformsOfItems(members) + else + platformsToShow + + + protected fun platformsOfItems(items: List): Set { val platforms = items.asSequence().map { when (it.kind) { - NodeKind.ExternalClass, NodeKind.Package, NodeKind.Module, NodeKind.GroupNode -> platformsOfItems(it.members) + NodeKind.ExternalClass, NodeKind.Package, NodeKind.Module -> platformsOfItems(it.members) + NodeKind.GroupNode -> platformsOfItems(it.origins) else -> it.platformsToShow.toSet() } } @@ -418,7 +492,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, val resultVersion = when { allKotlinVersions.size == 1 -> allKotlinVersions.single() minVersion.endsWith("+") -> minVersion - else -> minVersion + "+" + else -> "$minVersion+" } result.intersect(otherPlatforms) + resultVersion @@ -460,6 +534,15 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } + inner class SingleNodePageBuilder(val node: DocumentationNode, noHeader: Boolean = false) : + PageBuilder(listOf(node), noHeader) { + + override fun build() { + super.build() + SectionsBuilder(node).build() + } + } + inner class GroupNodePageBuilder(val node: DocumentationNode) : PageBuilder(listOf(node)) { override fun build() { @@ -470,39 +553,29 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendLine() appendHeader { appendText(node.name) } - fun DocumentationNode.priority(): Int = when (kind) { - NodeKind.TypeAlias -> 1 - NodeKind.Class -> 2 - else -> 3 - } - - for (member in node.members.sortedBy(DocumentationNode::priority)) { - - appendAsOverloadGroup(to, platformsOfItems(listOf(member))) { - formatSubNodeOfGroup(member) - } + renderGroupNode(node, true) + for (origin in node.origins) { + if (origin.content.isEmpty()) continue + appendStrong { to.append("Platform and version requirements:") } + to.append(" " + origin.actualPlatforms) + appendContent(origin.content.summary) } - } - fun formatSubNodeOfGroup(member: DocumentationNode) { - SingleNodePageBuilder(member, true).build() + SectionsBuilder(node).build() } } - inner class SingleNodePageBuilder(val node: DocumentationNode, noHeader: Boolean = false) - : PageBuilder(listOf(node), noHeader) { + inner class SectionsBuilder(val node: DocumentationNode): PageBuilder(listOf(node)) { override fun build() { - super.build() - if (node.kind == NodeKind.ExternalClass) { appendSection("Extensions for ${node.name}", node.members) return } fun DocumentationNode.membersOrGroupMembers(predicate: (DocumentationNode) -> Boolean): List { - return members.filter(predicate) + members(NodeKind.GroupNode).flatMap { it.members.filter(predicate) } + return members.filter(predicate) + members(NodeKind.GroupNode).filter{ it.origins.isNotEmpty() && predicate(it.origins.first()) } } fun DocumentationNode.membersOrGroupMembers(kind: NodeKind): List { @@ -510,10 +583,9 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } appendSection("Packages", node.members(NodeKind.Package), platformsBasedOnMembers = true) - appendSection("Types", node.membersOrGroupMembers { it.kind in NodeKind.classLike && it.kind != NodeKind.TypeAlias && it.kind != NodeKind.AnnotationClass && it.kind != NodeKind.Exception }) + appendSection("Types", node.membersOrGroupMembers { it.kind in NodeKind.classLike /*&& it.kind != NodeKind.TypeAlias*/ && it.kind != NodeKind.AnnotationClass && it.kind != NodeKind.Exception }) appendSection("Annotations", node.membersOrGroupMembers(NodeKind.AnnotationClass)) appendSection("Exceptions", node.membersOrGroupMembers(NodeKind.Exception)) - appendSection("Type Aliases", node.membersOrGroupMembers(NodeKind.TypeAlias)) appendSection("Extensions for External Classes", node.members(NodeKind.ExternalClass)) appendSection("Enum Values", node.membersOrGroupMembers(NodeKind.EnumItem), sortMembers = false, omitSamePlatforms = true) appendSection("Constructors", node.membersOrGroupMembers(NodeKind.Constructor), omitSamePlatforms = true) @@ -558,7 +630,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (node.kind == NodeKind.Module) { appendHeader(3) { to.append("Index") } node.members(NodeKind.AllTypes).singleOrNull()?.let { allTypes -> - appendLink(link(node, allTypes, { "All Types" })) + appendLink(link(node, allTypes) { "All Types" }) } } } @@ -594,11 +666,12 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } appendTableCell { - val breakdownBySummary = members.groupBy { it.summary } - for ((summary, items) in breakdownBySummary) { - appendSummarySignatures(items) - appendContent(summary) + val nodesToAppend = if (members.all { it.kind == NodeKind.GroupNode }) { + members.flatMap { it.origins } + } else { + members } + appendSummarySignatures(nodesToAppend, platformsBasedOnMembers, omitSamePlatforms) } } } @@ -614,27 +687,48 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, return emptySet() } - private fun appendSummarySignatures(items: List) { + private fun appendSummarySignatures(items: List, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) { val summarySignature = languageService.summarizeSignatures(items) if (summarySignature != null) { - appendAsSignature(summarySignature) { - summarySignature.appendSignature() - } + appendSummarySignature(summarySignature, items, platformsBasedOnMembers, omitSamePlatforms) return } - val renderedSignatures = items.map { languageService.render(it, RenderMode.SUMMARY) } - renderedSignatures.subList(0, renderedSignatures.size - 1).forEach { - appendAsSignature(it) { - it.appendSignature() - } - appendLine() + + + val groupBySignature = items.groupBy { + languageService.render(it, RenderMode.SUMMARY) } - appendAsSignature(renderedSignatures.last()) { - renderedSignatures.last().appendSignature() + for ((sign, node) in groupBySignature) { + appendSummarySignature(sign, node, platformsBasedOnMembers, omitSamePlatforms) } } + + private fun appendSummarySignature(signature: ContentNode, items: List, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) { + val elementPlatforms = platformsOfItems(items, omitSamePlatforms) + val platforms = if (platformsBasedOnMembers) + items.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms + else + elementPlatforms + + appendPlatforms(platforms) + appendAsSignature(signature) { + signature.appendSignature() + } + + appendContent(items.first().summary) + appendSoftLineBreak() + } } + private fun DocumentationNode.isClassLikeGroupNode(): Boolean { + if (kind != NodeKind.GroupNode) { + return false + } + + return origins.all { it.kind in NodeKind.classLike } + } + + inner class AllTypesNodeBuilder(val node: DocumentationNode) : PageBuilder(listOf(node)) { @@ -658,7 +752,13 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } appendTableCell { - appendContent(type.summary) + val summary = if (type.isClassLikeGroupNode()) { + type.origins.first().summary + } else { + type.summary + } + + appendContent(summary) } } } diff --git a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt index 6088d3a5..5b565464 100644 --- a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt +++ b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt @@ -198,7 +198,7 @@ class KotlinLanguageService : CommonLanguageService() { nowrap: Boolean ) { when (node.name) { - "final", "public", "var" -> { + "final", "public", "var", "expect", "actual" -> { } else -> { if (node.name !in fullOnlyModifiers || renderMode == RenderMode.FULL) { -- cgit From 0df19264ccae3d294946caf634ee15eea0c4fe4a Mon Sep 17 00:00:00 2001 From: Zubakov Date: Thu, 6 Sep 2018 19:44:50 +0300 Subject: Minor refactoring, kotlin-website format change: add platforms to summary signatures, platform evaluating logic change --- .../Formats/KotlinWebsiteHtmlFormatService.kt | 7 ++ .../main/kotlin/Formats/StructuredFormatService.kt | 123 +++++++++++++++------ core/src/main/kotlin/Model/DocumentationNode.kt | 6 +- 3 files changed, 103 insertions(+), 33 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 6ced75b5..16bec5a6 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -169,6 +169,13 @@ open class KotlinWebsiteHtmlOutputBuilder( appendContent(section) } } + + override fun appendAsBlockWithPlatforms(platforms: Set, block: () -> Unit) { + if (platforms.isNotEmpty()) + wrap("", "", block) + else + block() + } } class KotlinWebsiteHtmlFormatService @Inject constructor( diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index b57f21be..53172563 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -83,6 +83,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } + open fun appendAsBlockWithPlatforms(platforms: Set, block: () -> Unit) { + block() + } + open fun appendSymbol(text: String) { appendText(text) } @@ -465,6 +469,18 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, platformsToShow + protected fun mergeVersions(otherKotlinVersion: String, kotlinVersions: List): String { + val allKotlinVersions = (kotlinVersions + otherKotlinVersion).distinct() + + val minVersion = allKotlinVersions.min()!! + val resultVersion: String = when { + allKotlinVersions.size == 1 -> allKotlinVersions.single() + minVersion.endsWith("+") -> minVersion + else -> "$minVersion+" + } + + return resultVersion + } protected fun platformsOfItems(items: List): Set { val platforms = items.asSequence().map { @@ -486,19 +502,38 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, // When no Kotlin version specified, it means that version is 1.0 if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) { - val allKotlinVersions = (kotlinVersions + otherKotlinVersion).distinct() + result.intersect(platformsOfItem) + mergeVersions(otherKotlinVersion, kotlinVersions) + } else { + result.intersect(platformsOfItem) + } + } + } - val minVersion = allKotlinVersions.min()!! - val resultVersion = when { - allKotlinVersions.size == 1 -> allKotlinVersions.single() - minVersion.endsWith("+") -> minVersion - else -> "$minVersion+" - } + protected fun unionPlatformsOfItems(items: List): Set { + val platforms = items.asSequence().map { + when (it.kind) { + NodeKind.GroupNode -> unionPlatformsOfItems(it.origins) + else -> it.platformsToShow.toSet() + } + } + + fun String.isKotlinVersion() = this.startsWith("Kotlin") + + if (platforms.count() == 0) return emptySet() + + // Calculating common platforms for items + return platforms.reduce { result, platformsOfItem -> + val otherKotlinVersion = result.find { it.isKotlinVersion() } + val (kotlinVersions, otherPlatforms) = platformsOfItem.partition { it.isKotlinVersion() } - result.intersect(otherPlatforms) + resultVersion + // When no Kotlin version specified, it means that version is 1.0 + if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) { + result.union(otherPlatforms) + mergeVersions(otherKotlinVersion, kotlinVersions) } else { - result.intersect(platformsOfItem) + result.union(otherPlatforms) } + }.let { + if (it.containsAll(impliedPlatforms)) it - impliedPlatforms else it } } @@ -566,6 +601,17 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } + private fun unionPlatformsOfItems(items: List): Set { + val platforms = items.flatMapTo(mutableSetOf()) { + when (it.kind) { + NodeKind.GroupNode -> unionPlatformsOfItems(it.origins) + else -> it.platforms + } + } + + return platforms.let { if (it.containsAll(impliedPlatforms)) it - impliedPlatforms else it } + } + inner class SectionsBuilder(val node: DocumentationNode): PageBuilder(listOf(node)) { override fun build() { @@ -666,12 +712,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } appendTableCell { - val nodesToAppend = if (members.all { it.kind == NodeKind.GroupNode }) { - members.flatMap { it.origins } - } else { - members - } - appendSummarySignatures(nodesToAppend, platformsBasedOnMembers, omitSamePlatforms) + appendSummarySignatures(members, platformsBasedOnMembers, omitSamePlatforms) } } } @@ -680,6 +721,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } private fun platformsOfItems(items: List, omitSamePlatforms: Boolean = true): Set { + if (items.all { it.kind != NodeKind.Package && it.kind != NodeKind.Module && it.kind != NodeKind.ExternalClass }) { + return unionPlatformsOfItems(items) + } + val platforms = platformsOfItems(items) if (platforms.isNotEmpty() && (platforms != node.platformsToShow.toSet() || !omitSamePlatforms)) { return platforms @@ -688,35 +733,49 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } private fun appendSummarySignatures(items: List, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) { - val summarySignature = languageService.summarizeSignatures(items) - if (summarySignature != null) { - appendSummarySignature(summarySignature, items, platformsBasedOnMembers, omitSamePlatforms) - return - } + val groupBySummary = items.groupBy { it.summary } + for ((summary, node) in groupBySummary) { + val nodesToAppend = if (node.all { it.kind == NodeKind.GroupNode }) { + node.flatMap { it.origins } + } else { + node + } - val groupBySignature = items.groupBy { - languageService.render(it, RenderMode.SUMMARY) - } - for ((sign, node) in groupBySignature) { - appendSummarySignature(sign, node, platformsBasedOnMembers, omitSamePlatforms) + val summarySignature = languageService.summarizeSignatures(nodesToAppend) + if (summarySignature != null) { + appendSignatures(summarySignature, items, platformsBasedOnMembers, omitSamePlatforms) + } else { + val groupBySignature = nodesToAppend.groupBy { + languageService.render(it, RenderMode.SUMMARY) + } + for ((sign, members) in groupBySignature) { + appendSignatures(sign, members, platformsBasedOnMembers, omitSamePlatforms) + } + } + + val platforms = platformsOfItems(node) + appendAsBlockWithPlatforms(platforms) { + appendContent(summary) + appendSoftLineBreak() + } } } - private fun appendSummarySignature(signature: ContentNode, items: List, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) { + private fun appendSignatures(signature: ContentNode, items: List, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) { val elementPlatforms = platformsOfItems(items, omitSamePlatforms) val platforms = if (platformsBasedOnMembers) items.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms else elementPlatforms - appendPlatforms(platforms) - appendAsSignature(signature) { - signature.appendSignature() + appendAsBlockWithPlatforms(platforms) { + appendPlatforms(platforms) + appendAsSignature(signature) { + signature.appendSignature() + } + appendSoftLineBreak() } - - appendContent(items.first().summary) - appendSoftLineBreak() } } diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt index 146c1e99..f2b3a937 100644 --- a/core/src/main/kotlin/Model/DocumentationNode.kt +++ b/core/src/main/kotlin/Model/DocumentationNode.kt @@ -76,7 +76,11 @@ open class DocumentationNode(val name: String, var content: Content = content private set - val summary: ContentNode get() = content.summary + val summary: ContentNode get() = when (kind) { + NodeKind.GroupNode -> this.origins.first().summary + else -> content.summary + } + val owner: DocumentationNode? get() = references(RefKind.Owner).singleOrNull()?.to -- cgit From 312b50005bae6cbdea6a203c37bee3006a90b641 Mon Sep 17 00:00:00 2001 From: Zubakov Date: Fri, 21 Sep 2018 16:03:51 +0300 Subject: Fix number of platforms bubbles --- .../main/kotlin/Formats/StructuredFormatService.kt | 37 ++++++++++++++++++---- 1 file changed, 30 insertions(+), 7 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 53172563..927e0827 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -712,7 +712,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } appendTableCell { - appendSummarySignatures(members, platformsBasedOnMembers, omitSamePlatforms) + appendSummarySignatures(members, platformsBasedOnMembers, omitSamePlatforms, platforms) } } } @@ -732,7 +732,12 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, return emptySet() } - private fun appendSummarySignatures(items: List, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) { + private fun appendSummarySignatures( + items: List, + platformsBasedOnMembers: Boolean, + omitSamePlatforms: Boolean, + parentPlatforms: Set + ) { val groupBySummary = items.groupBy { it.summary } for ((summary, node) in groupBySummary) { @@ -744,32 +749,50 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, val summarySignature = languageService.summarizeSignatures(nodesToAppend) if (summarySignature != null) { - appendSignatures(summarySignature, items, platformsBasedOnMembers, omitSamePlatforms) + appendSignatures(summarySignature, items, platformsBasedOnMembers, omitSamePlatforms, parentPlatforms) } else { val groupBySignature = nodesToAppend.groupBy { languageService.render(it, RenderMode.SUMMARY) } for ((sign, members) in groupBySignature) { - appendSignatures(sign, members, platformsBasedOnMembers, omitSamePlatforms) + appendSignatures(sign, members, platformsBasedOnMembers, omitSamePlatforms, parentPlatforms) } } val platforms = platformsOfItems(node) - appendAsBlockWithPlatforms(platforms) { + val platformsToAppend = if (platforms == parentPlatforms) { + emptySet() + } else { + platforms + } + appendAsBlockWithPlatforms(platformsToAppend) { appendContent(summary) appendSoftLineBreak() } } } - private fun appendSignatures(signature: ContentNode, items: List, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) { + private fun appendSignatures( + signature: ContentNode, + items: List, + platformsBasedOnMembers: Boolean, + omitSamePlatforms: Boolean, + parentPlatforms: Set + ) { val elementPlatforms = platformsOfItems(items, omitSamePlatforms) val platforms = if (platformsBasedOnMembers) items.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms else elementPlatforms - appendAsBlockWithPlatforms(platforms) { + + val platformsToAppend = if (platforms == parentPlatforms) { + emptySet() + } else { + platforms + } + + appendAsBlockWithPlatforms(platformsToAppend) { appendPlatforms(platforms) appendAsSignature(signature) { signature.appendSignature() -- cgit From f2bfbc788a995daed52d3c0d587223d7b21cb3cc Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 26 Sep 2018 00:32:08 +0300 Subject: Refactor platforms & SinceKotlin logic --- .../Formats/KotlinWebsiteHtmlFormatService.kt | 7 +- .../main/kotlin/Formats/StructuredFormatService.kt | 292 ++++++++++++--------- .../src/main/kotlin/Kotlin/DocumentationBuilder.kt | 2 +- core/src/main/kotlin/Model/DocumentationNode.kt | 7 + .../main/kotlin/Model/DocumentationReference.kt | 3 +- 5 files changed, 180 insertions(+), 131 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 16bec5a6..e5dd57a7 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -125,14 +125,16 @@ open class KotlinWebsiteHtmlOutputBuilder( fun calculateDataAttributes(platforms: Set): String { fun String.isKotlinVersion() = this.startsWith("Kotlin") fun String.isJREVersion() = this.startsWith("JRE") + fun String.isNoBubbles() = this.startsWith("NoBubbles") val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion) val jreVersion = platforms.singleOrNull(String::isJREVersion) - val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } + val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() || it.isNoBubbles() } val kotlinVersionAttr = kotlinVersion?.let { " data-kotlin-version=\"$it\"" } ?: "" val jreVersionAttr = jreVersion?.let { " data-jre-version=\"$it\"" } ?: "" val platformsAttr = targetPlatforms.ifNotEmpty { " data-platform=\"${targetPlatforms.joinToString()}\"" } ?: "" - return "$platformsAttr$kotlinVersionAttr$jreVersionAttr" + val classes = if (NoBubbles in platforms) " class=\"no-bubbles\"" else "" + return "$classes$platformsAttr$kotlinVersionAttr$jreVersionAttr" } override fun appendIndexRow(platforms: Set, block: () -> Unit) { @@ -191,3 +193,4 @@ class KotlinWebsiteHtmlFormatService @Inject constructor( KotlinWebsiteHtmlOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms, templateService) } +val NoBubbles = "NoBubbles" \ No newline at end of file diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 927e0827..c5b6c8eb 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -10,7 +10,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, val generator: NodeLocationAwareGenerator, val languageService: LanguageService, val extension: String, - val impliedPlatforms: List) : FormattedOutputBuilder { + impliedPlatforms: List) : FormattedOutputBuilder { protected fun DocumentationNode.location() = generator.location(this) @@ -312,7 +312,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } else { for ((_, items) in breakdownBySummary) { - appendAsOverloadGroup(to, platformsOfItems(items)) { + appendAsOverloadGroup(to, effectivePlatformsForMembers(items)) { formatOverloadGroup(items) } @@ -463,82 +463,64 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } val DocumentationNode.actualPlatforms: Collection - get() = if (isModuleOrPackage()) - platformsToShow.toSet() + platformsOfItems(members) - else - platformsToShow - - - protected fun mergeVersions(otherKotlinVersion: String, kotlinVersions: List): String { - val allKotlinVersions = (kotlinVersions + otherKotlinVersion).distinct() - - val minVersion = allKotlinVersions.min()!! - val resultVersion: String = when { - allKotlinVersions.size == 1 -> allKotlinVersions.single() - minVersion.endsWith("+") -> minVersion - else -> "$minVersion+" - } - - return resultVersion - } - - protected fun platformsOfItems(items: List): Set { - val platforms = items.asSequence().map { - when (it.kind) { - NodeKind.ExternalClass, NodeKind.Package, NodeKind.Module -> platformsOfItems(it.members) - NodeKind.GroupNode -> platformsOfItems(it.origins) - else -> it.platformsToShow.toSet() - } - } - - fun String.isKotlinVersion() = this.startsWith("Kotlin") - - if (platforms.count() == 0) return emptySet() - - // Calculating common platforms for items - return platforms.reduce { result, platformsOfItem -> - val otherKotlinVersion = result.find { it.isKotlinVersion() } - val (kotlinVersions, otherPlatforms) = platformsOfItem.partition { it.isKotlinVersion() } - - // When no Kotlin version specified, it means that version is 1.0 - if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) { - result.intersect(platformsOfItem) + mergeVersions(otherKotlinVersion, kotlinVersions) - } else { - result.intersect(platformsOfItem) - } - } - } - - protected fun unionPlatformsOfItems(items: List): Set { - val platforms = items.asSequence().map { - when (it.kind) { - NodeKind.GroupNode -> unionPlatformsOfItems(it.origins) - else -> it.platformsToShow.toSet() - } - } - - fun String.isKotlinVersion() = this.startsWith("Kotlin") - - if (platforms.count() == 0) return emptySet() - - // Calculating common platforms for items - return platforms.reduce { result, platformsOfItem -> - val otherKotlinVersion = result.find { it.isKotlinVersion() } - val (kotlinVersions, otherPlatforms) = platformsOfItem.partition { it.isKotlinVersion() } - - // When no Kotlin version specified, it means that version is 1.0 - if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) { - result.union(otherPlatforms) + mergeVersions(otherKotlinVersion, kotlinVersions) - } else { - result.union(otherPlatforms) - } - }.let { - if (it.containsAll(impliedPlatforms)) it - impliedPlatforms else it - } - } - - val DocumentationNode.platformsToShow: List - get() = platforms.let { if (it.containsAll(impliedPlatforms)) it - impliedPlatforms else it } + get() = effectivePlatformsForNode(this) + + +// protected fun platformsOfItems(items: List): Set { +// val platforms = items.asSequence().map { +// when (it.kind) { +// NodeKind.ExternalClass, NodeKind.Package, NodeKind.Module -> platformsOfItems(it.members) +// NodeKind.GroupNode -> platformsOfItems(it.origins) +// else -> it.platformsToShow.toSet() +// } +// } +// +// fun String.isKotlinVersion() = this.startsWith("Kotlin") +// +// if (platforms.count() == 0) return emptySet() +// +// // Calculating common platforms for items +// return platforms.reduce { result, platformsOfItem -> +// val otherKotlinVersion = result.find { it.isKotlinVersion() } +// val (kotlinVersions, otherPlatforms) = platformsOfItem.partition { it.isKotlinVersion() } +// +// // When no Kotlin version specified, it means that version is 1.0 +// if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) { +// result.intersect(platformsOfItem) + mergeVersions(otherKotlinVersion, kotlinVersions) +// } else { +// result.intersect(platformsOfItem) +// } +// } +// } +// +// protected fun unionPlatformsOfItems(items: List): Set { +// val platforms = items.asSequence().map { +// when (it.kind) { +// NodeKind.GroupNode -> unionPlatformsOfItems(it.origins) +// else -> it.platformsToShow.toSet() +// } +// } +// +// fun String.isKotlinVersion() = this.startsWith("Kotlin") +// +// if (platforms.count() == 0) return emptySet() +// +// // Calculating common platforms for items +// return platforms.reduce { result, platformsOfItem -> +// val otherKotlinVersion = result.find { it.isKotlinVersion() } +// val (kotlinVersions, otherPlatforms) = platformsOfItem.partition { it.isKotlinVersion() } +// +// // When no Kotlin version specified, it means that version is 1.0 +// if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) { +// result.union(otherPlatforms) + mergeVersions(otherKotlinVersion, kotlinVersions) +// } else { +// result.union(otherPlatforms) +// } +// } +// } + +// val DocumentationNode.platformsToShow: List +// get() = platforms private fun DocumentationNode.appendDescription() { if (content.description != ContentEmpty) { @@ -600,17 +582,17 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, SectionsBuilder(node).build() } } - - private fun unionPlatformsOfItems(items: List): Set { - val platforms = items.flatMapTo(mutableSetOf()) { - when (it.kind) { - NodeKind.GroupNode -> unionPlatformsOfItems(it.origins) - else -> it.platforms - } - } - - return platforms.let { if (it.containsAll(impliedPlatforms)) it - impliedPlatforms else it } - } +// +// private fun unionPlatformsOfItems(items: List): Set { +// val platforms = items.flatMapTo(mutableSetOf()) { +// when (it.kind) { +// NodeKind.GroupNode -> unionPlatformsOfItems(it.origins) +// else -> it.platforms +// } +// } +// +// return platforms +// } inner class SectionsBuilder(val node: DocumentationNode): PageBuilder(listOf(node)) { @@ -697,11 +679,11 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendTable("Name", "Summary") { appendTableBody { for ((memberLocation, members) in membersMap) { - val elementPlatforms = platformsOfItems(members, omitSamePlatforms) - val platforms = if (platformsBasedOnMembers) - members.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms - else - elementPlatforms + val platforms = effectivePlatformsForMembers(members) + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(members)) +// val platforms = if (platformsBasedOnMembers) +// members.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms +// else +// elementPlatforms appendIndexRow(platforms) { appendTableCell { appendParagraph { @@ -720,17 +702,18 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } - private fun platformsOfItems(items: List, omitSamePlatforms: Boolean = true): Set { - if (items.all { it.kind != NodeKind.Package && it.kind != NodeKind.Module && it.kind != NodeKind.ExternalClass }) { - return unionPlatformsOfItems(items) - } - - val platforms = platformsOfItems(items) - if (platforms.isNotEmpty() && (platforms != node.platformsToShow.toSet() || !omitSamePlatforms)) { - return platforms - } - return emptySet() - } +// +// private fun platformsOfItems(items: List, omitSamePlatforms: Boolean = true): Set { +// if (items.all { it.kind != NodeKind.Package && it.kind != NodeKind.Module && it.kind != NodeKind.ExternalClass }) { +// return unionPlatformsOfItems(items) +// } +// +// val platforms = platformsOfItems(items) +// if (platforms.isNotEmpty() && (platforms != node.platformsToShow.toSet() || !omitSamePlatforms)) { +// return platforms +// } +// return emptySet() +// } private fun appendSummarySignatures( items: List, @@ -740,16 +723,16 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, ) { val groupBySummary = items.groupBy { it.summary } - for ((summary, node) in groupBySummary) { - val nodesToAppend = if (node.all { it.kind == NodeKind.GroupNode }) { - node.flatMap { it.origins } + for ((summary, nodes) in groupBySummary) { + val nodesToAppend = if (nodes.all { it.kind == NodeKind.GroupNode }) { + nodes.flatMap { it.origins } } else { - node + nodes } val summarySignature = languageService.summarizeSignatures(nodesToAppend) if (summarySignature != null) { - appendSignatures(summarySignature, items, platformsBasedOnMembers, omitSamePlatforms, parentPlatforms) + appendSignatures(summarySignature, nodes, platformsBasedOnMembers, omitSamePlatforms, parentPlatforms) } else { val groupBySignature = nodesToAppend.groupBy { languageService.render(it, RenderMode.SUMMARY) @@ -759,12 +742,8 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } - val platforms = platformsOfItems(node) - val platformsToAppend = if (platforms == parentPlatforms) { - emptySet() - } else { - platforms - } + val platforms = effectivePlatformsForMembers(nodes) + val platformsToAppend = platforms + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(nodes)) + NoBubbles appendAsBlockWithPlatforms(platformsToAppend) { appendContent(summary) appendSoftLineBreak() @@ -779,18 +758,14 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, omitSamePlatforms: Boolean, parentPlatforms: Set ) { - val elementPlatforms = platformsOfItems(items, omitSamePlatforms) - val platforms = if (platformsBasedOnMembers) - items.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms - else - elementPlatforms + val platforms = effectivePlatformsForMembers(items) +// val platforms = if (platformsBasedOnMembers) +// items.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms +// else +// elementPlatforms - - val platformsToAppend = if (platforms == parentPlatforms) { - emptySet() - } else { - platforms - } + print("signature>") + val platformsToAppend = platforms + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(items)) appendAsBlockWithPlatforms(platformsToAppend) { appendPlatforms(platforms) @@ -866,3 +841,66 @@ abstract class StructuredFormatService(val generator: NodeLocationAwareGenerator override final val linkExtension: String = extension) : FormatService { } + + +fun memberPlatforms(node: DocumentationNode): Sequence> { + val members = when { + node.kind == NodeKind.GroupNode -> node.origins + else -> node.members + } + + return members.asSequence() + .map { effectivePlatformsForNode(it) } +} + +fun effectivePlatformsForNode(node: DocumentationNode): Set { + val platforms = + sequenceOf(node.platforms.toSet()) + memberPlatforms(node) + + + // Calculating common platforms for items + return platforms.reduce { result, platformsOfItem -> + result.union(platformsOfItem) + } +} + +fun effectivePlatformsForMembers(nodes: List): Set { + return nodes.map { effectivePlatformsForNode(it) }.reduce { acc, set -> + acc.union(set) + } +} + +fun mergeVersions(kotlinVersions: List): String { + val allKotlinVersions = kotlinVersions.distinct() + + val minVersion = allKotlinVersions.min()!! + val resultVersion: String = when { + allKotlinVersions.size == 1 -> allKotlinVersions.single() + minVersion.endsWith("+") -> minVersion + else -> "$minVersion+" + } + + return resultVersion +} + +fun effectiveSinceKotlinForNode(node: DocumentationNode, baseVersion: String = "1.0"): String { + val members = when { + node.kind == NodeKind.GroupNode -> node.origins + node.kind in NodeKind.classLike -> emptyList() + node.kind in NodeKind.memberLike -> emptyList() + else -> node.members + } + + val nodeVersion = node.sinceKotlin ?: baseVersion + val memberVersion = if (members.isNotEmpty()) effectiveSinceKotlinForNodes(members, nodeVersion) else nodeVersion + + println("${node.path} > $nodeVersion, $memberVersion") + + return mergeVersions(listOf(memberVersion, nodeVersion)) +} + +fun effectiveSinceKotlinForNodes(nodes: List, baseVersion: String = "1.0"): String { + return mergeVersions(nodes.map { effectiveSinceKotlinForNode(it, baseVersion) }) +} + +fun sinceKotlinAsPlatform(version: String): String = "Kotlin $version" diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt index e5bc32ab..38d2df4a 100644 --- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt +++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt @@ -275,7 +275,7 @@ class DocumentationBuilder .detail(NodeKind.Value) .name.removeSurrounding("\"") - append(platformNodeRegistry["Kotlin " + kotlinVersion], RefKind.Platform) + sinceKotlin = kotlinVersion } fun DocumentationNode.appendModifiers(descriptor: DeclarationDescriptor) { diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt index f2b3a937..5607c6d3 100644 --- a/core/src/main/kotlin/Model/DocumentationNode.kt +++ b/core/src/main/kotlin/Model/DocumentationNode.kt @@ -116,6 +116,13 @@ open class DocumentationNode(val name: String, val externalType: DocumentationNode? get() = references(RefKind.ExternalType).map { it.to }.firstOrNull() + var sinceKotlin: String? + get() = references(RefKind.SinceKotlin).singleOrNull()?.to?.name + set(value) { + if(value == null) return dropReferences { it.kind == RefKind.SinceKotlin } + append(DocumentationNode(value, Content.Empty, NodeKind.Value), RefKind.SinceKotlin) + } + val supertypes: List get() = details(NodeKind.Supertype) diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt index e10796d2..1f2fc0c9 100644 --- a/core/src/main/kotlin/Model/DocumentationReference.kt +++ b/core/src/main/kotlin/Model/DocumentationReference.kt @@ -20,7 +20,8 @@ enum class RefKind { TopLevelPage, Platform, ExternalType, - Origin + Origin, + SinceKotlin } data class DocumentationReference(val from: DocumentationNode, val to: DocumentationNode, val kind: RefKind) { -- cgit From cffc71e39f20a368f2ffe10bf0c8aa4432dee7fc Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 26 Sep 2018 22:14:40 +0300 Subject: Change logic of platforms rendering --- .../Formats/KotlinWebsiteHtmlFormatService.kt | 22 +++-- .../main/kotlin/Formats/StructuredFormatService.kt | 110 ++++++++++----------- 2 files changed, 66 insertions(+), 66 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index e5dd57a7..66eb60c4 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -125,16 +125,16 @@ open class KotlinWebsiteHtmlOutputBuilder( fun calculateDataAttributes(platforms: Set): String { fun String.isKotlinVersion() = this.startsWith("Kotlin") fun String.isJREVersion() = this.startsWith("JRE") - fun String.isNoBubbles() = this.startsWith("NoBubbles") + val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion) val jreVersion = platforms.singleOrNull(String::isJREVersion) - val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() || it.isNoBubbles() } + val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } + val kotlinVersionAttr = kotlinVersion?.let { " data-kotlin-version=\"$it\"" } ?: "" val jreVersionAttr = jreVersion?.let { " data-jre-version=\"$it\"" } ?: "" val platformsAttr = targetPlatforms.ifNotEmpty { " data-platform=\"${targetPlatforms.joinToString()}\"" } ?: "" - val classes = if (NoBubbles in platforms) " class=\"no-bubbles\"" else "" - return "$classes$platformsAttr$kotlinVersionAttr$jreVersionAttr" + return "$platformsAttr$kotlinVersionAttr$jreVersionAttr" } override fun appendIndexRow(platforms: Set, block: () -> Unit) { @@ -144,7 +144,9 @@ open class KotlinWebsiteHtmlOutputBuilder( appendTableRow(block) } - override fun appendPlatforms(platforms: Set) {} + override fun appendPlatforms(platforms: Set) { + div(to, "tags") {} + } override fun appendBreadcrumbSeparator() { to.append(" / ") @@ -172,11 +174,13 @@ open class KotlinWebsiteHtmlOutputBuilder( } } - override fun appendAsBlockWithPlatforms(platforms: Set, block: () -> Unit) { + override fun appendAsPlatformDependentBlock(platforms: Set, block: (Set) -> Unit) { if (platforms.isNotEmpty()) - wrap("", "", block) + wrap("", "") { + block(platforms) + } else - block() + block(platforms) } } @@ -192,5 +196,3 @@ class KotlinWebsiteHtmlFormatService @Inject constructor( override fun createOutputBuilder(to: StringBuilder, location: Location) = KotlinWebsiteHtmlOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms, templateService) } - -val NoBubbles = "NoBubbles" \ No newline at end of file diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index c5b6c8eb..04710694 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -83,8 +83,8 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } - open fun appendAsBlockWithPlatforms(platforms: Set, block: () -> Unit) { - block() + open fun appendAsPlatformDependentBlock(platforms: Set, block: (Set) -> Unit) { + block(platforms) } open fun appendSymbol(text: String) { @@ -311,11 +311,9 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, formatOverloadGroup(breakdownBySummary.values.single(), isSingleNode) } else { for ((_, items) in breakdownBySummary) { - - appendAsOverloadGroup(to, effectivePlatformsForMembers(items)) { + appendAsOverloadGroup(to, effectivePlatformAndVersion(items)) { formatOverloadGroup(items) } - } } } @@ -339,19 +337,23 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } if (item.kind == NodeKind.GroupNode) { - for (origin in item.origins) { - if (origin.content.isEmpty()) continue - appendParagraph { - appendStrong { to.append("Platform and version requirements:") } - to.append(" " + origin.actualPlatforms) - appendContent(origin.summary) + for ((content, origins) in item.origins.groupBy { it.content }) { + if (content.isEmpty()) continue + val platforms = effectivePlatformsForMembers(origins) + appendAsPlatformDependentBlock(platforms) { + appendPlatforms(platforms) + appendParagraph { + appendContent(content) + } } } } else { if (!item.content.isEmpty()) { - appendStrong { to.append("Platform and version requirements:") } - to.append(" " + item.actualPlatforms) - appendContent(item.content.summary) + val platforms = effectivePlatformsForNode(item) + appendAsPlatformDependentBlock(platforms) { + appendPlatforms(platforms) + appendContent(item.content) + } } } @@ -382,26 +384,19 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } for ((sign, nodes) in groupBySignature) { - val first = nodes.first() - first.detailOrNull(NodeKind.Signature)?.let { - if (item.kind !in NodeKind.classLike || !isSingleNode) - appendAnchor(it.name) - } - - appendAsSignature(sign) { - appendCode { appendContent(sign) } - } - first.appendOverrides() - first.appendDeprecation() - + appendAsPlatformDependentBlock(effectivePlatformAndVersion(nodes)) { platforms -> + val first = nodes.first() + first.detailOrNull(NodeKind.Signature)?.let { + if (item.kind !in NodeKind.classLike || !isSingleNode) + appendAnchor(it.name) + } - appendParagraph { - appendStrong { to.append("Platform and version requirements:") } - to.append(" " + nodes - .flatMap { it.actualPlatforms } - .distinct() - .joinToString() - ) + appendAsSignature(sign) { + appendCode { appendContent(sign) } + } + appendPlatforms(platforms) + first.appendOverrides() + first.appendDeprecation() } } @@ -463,7 +458,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } val DocumentationNode.actualPlatforms: Collection - get() = effectivePlatformsForNode(this) + get() = effectivePlatformAndVersion(listOf(this)) // protected fun platformsOfItems(items: List): Set { @@ -572,11 +567,13 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, renderGroupNode(node, true) - for (origin in node.origins) { - if (origin.content.isEmpty()) continue - appendStrong { to.append("Platform and version requirements:") } - to.append(" " + origin.actualPlatforms) - appendContent(origin.content.summary) + for ((content, origins) in node.origins.groupBy { it.content }) { + if (content.isEmpty()) continue + val platforms = effectivePlatformAndVersion(origins) + appendAsPlatformDependentBlock(platforms) { + appendPlatforms(platforms) + appendContent(content) + } } SectionsBuilder(node).build() @@ -679,7 +676,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendTable("Name", "Summary") { appendTableBody { for ((memberLocation, members) in membersMap) { - val platforms = effectivePlatformsForMembers(members) + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(members)) + val platforms = emptySet() // val platforms = if (platformsBasedOnMembers) // members.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms // else @@ -688,12 +685,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendTableCell { appendParagraph { appendLink(memberLocation) - if (members.singleOrNull()?.kind != NodeKind.ExternalClass) { - appendPlatforms(platforms) - } +// if (members.singleOrNull()?.kind != NodeKind.ExternalClass) { +// appendPlatforms(platforms) +// } } - } - appendTableCell { appendSummarySignatures(members, platformsBasedOnMembers, omitSamePlatforms, platforms) } } @@ -742,9 +737,8 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } - val platforms = effectivePlatformsForMembers(nodes) - val platformsToAppend = platforms + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(nodes)) + NoBubbles - appendAsBlockWithPlatforms(platformsToAppend) { + val platformsToAppend = effectivePlatformAndVersion(nodes) + appendAsPlatformDependentBlock(platformsToAppend) { appendContent(summary) appendSoftLineBreak() } @@ -758,21 +752,20 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, omitSamePlatforms: Boolean, parentPlatforms: Set ) { - val platforms = effectivePlatformsForMembers(items) + // val platforms = if (platformsBasedOnMembers) // items.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms // else // elementPlatforms - print("signature>") - val platformsToAppend = platforms + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(items)) + val platformsToAppend = effectivePlatformAndVersion(items) - appendAsBlockWithPlatforms(platformsToAppend) { - appendPlatforms(platforms) - appendAsSignature(signature) { - signature.appendSignature() - } + appendAsPlatformDependentBlock(platformsToAppend) { + appendAsSignature(signature) { + signature.appendSignature() + } appendSoftLineBreak() + appendPlatforms(platformsToAppend) } } } @@ -904,3 +897,8 @@ fun effectiveSinceKotlinForNodes(nodes: List, baseVersion: St } fun sinceKotlinAsPlatform(version: String): String = "Kotlin $version" + + +fun effectivePlatformAndVersion(nodes: List, baseVersion: String = "1.0"): Set { + return effectivePlatformsForMembers(nodes) + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(nodes, baseVersion)) +} -- cgit From 960e022f7b94d858942f938dd9f7b877f2435964 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 26 Sep 2018 22:15:03 +0300 Subject: Take implied platforms back --- core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 66eb60c4..718c8d35 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -20,7 +20,7 @@ open class KotlinWebsiteHtmlOutputBuilder( generator: NodeLocationAwareGenerator, languageService: LanguageService, extension: String, - impliedPlatforms: List, + val impliedPlatforms: List, templateService: HtmlTemplateService ) : HtmlOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms, templateService) { private var needHardLineBreaks = false @@ -128,7 +128,10 @@ open class KotlinWebsiteHtmlOutputBuilder( val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion) val jreVersion = platforms.singleOrNull(String::isJREVersion) - val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } + val targetPlatforms = + platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } + .takeUnless { it.intersect(impliedPlatforms).containsAll(impliedPlatforms) } + .orEmpty() val kotlinVersionAttr = kotlinVersion?.let { " data-kotlin-version=\"$it\"" } ?: "" -- cgit From 31af10e09963096389a4201ec1b0f8d9a11bb7f6 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Thu, 27 Sep 2018 18:22:10 +0300 Subject: Insert platforms on dokka side --- .../Formats/KotlinWebsiteHtmlFormatService.kt | 35 +++++++++++++++++----- 1 file changed, 27 insertions(+), 8 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 718c8d35..d2321ad9 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -122,22 +122,32 @@ open class KotlinWebsiteHtmlOutputBuilder( else -> "identifier" } - fun calculateDataAttributes(platforms: Set): String { + private fun calculatePlatforms(platforms: Set): Map> { + fun String.isKotlinVersion() = this.startsWith("Kotlin") fun String.isJREVersion() = this.startsWith("JRE") - val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion) + val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion)?.removePrefix("Kotlin ") val jreVersion = platforms.singleOrNull(String::isJREVersion) val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } .takeUnless { it.intersect(impliedPlatforms).containsAll(impliedPlatforms) } .orEmpty() + return mapOf( + "platform" to targetPlatforms, + "kotlin-version" to listOfNotNull(kotlinVersion), + "jre-version" to listOfNotNull(jreVersion) + ) + } - val kotlinVersionAttr = kotlinVersion?.let { " data-kotlin-version=\"$it\"" } ?: "" - val jreVersionAttr = jreVersion?.let { " data-jre-version=\"$it\"" } ?: "" - val platformsAttr = targetPlatforms.ifNotEmpty { " data-platform=\"${targetPlatforms.joinToString()}\"" } ?: "" - return "$platformsAttr$kotlinVersionAttr$jreVersionAttr" + private fun calculateDataAttributes(platforms: Set): String { + val platformsByKind = calculatePlatforms(platforms) + return platformsByKind + .entries.filterNot { it.value.isEmpty() } + .joinToString(separator = " ") { (kind, values) -> + "data-$kind=\"${values.joinToString()}\"" + } } override fun appendIndexRow(platforms: Set, block: () -> Unit) { @@ -148,7 +158,16 @@ open class KotlinWebsiteHtmlOutputBuilder( } override fun appendPlatforms(platforms: Set) { - div(to, "tags") {} + val platformsToKind = calculatePlatforms(platforms) + div(to, "tags") { + platformsToKind.entries.forEach { (kind, values) -> + values.forEach { value -> + div(to, "tags__tag $kind") { + to.append(value) + } + } + } + } } override fun appendBreadcrumbSeparator() { @@ -179,7 +198,7 @@ open class KotlinWebsiteHtmlOutputBuilder( override fun appendAsPlatformDependentBlock(platforms: Set, block: (Set) -> Unit) { if (platforms.isNotEmpty()) - wrap("", "") { + wrap("
", "
") { block(platforms) } else -- cgit From 8422874793845c1bb5234b91f858d74e80c956f7 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Thu, 27 Sep 2018 18:22:49 +0300 Subject: Render signatures in platform dependent block --- .../main/kotlin/Formats/StructuredFormatService.kt | 40 ++++++++++++---------- 1 file changed, 21 insertions(+), 19 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 04710694..162976a6 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -362,19 +362,21 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, fun renderSimpleNode(item: DocumentationNode, isSingleNode: Boolean) { - // TODO: use summarizesignatures - val rendered = languageService.render(item) - item.detailOrNull(NodeKind.Signature)?.let { - if (item.kind !in NodeKind.classLike || !isSingleNode) - appendAnchor(it.name) - } - appendAsSignature(rendered) { - appendCode { appendContent(rendered) } - item.appendSourceLink() - } - item.appendOverrides() - item.appendDeprecation() - item.appendPlatforms() + appendAsPlatformDependentBlock(effectivePlatformAndVersion(listOf(item))) { platforms -> + // TODO: use summarizesignatures + val rendered = languageService.render(item) + item.detailOrNull(NodeKind.Signature)?.let { + if (item.kind !in NodeKind.classLike || !isSingleNode) + appendAnchor(it.name) + } + appendAsSignature(rendered) { + appendCode { appendContent(rendered) } + item.appendSourceLink() + } + item.appendOverrides() + item.appendDeprecation() + appendPlatforms(platforms) + } } fun renderGroupNode(item: DocumentationNode, isSingleNode: Boolean) { @@ -725,6 +727,12 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, nodes } + val platformsToAppend = effectivePlatformAndVersion(nodes) + appendAsPlatformDependentBlock(platformsToAppend) { + appendContent(summary) + appendSoftLineBreak() + } + val summarySignature = languageService.summarizeSignatures(nodesToAppend) if (summarySignature != null) { appendSignatures(summarySignature, nodes, platformsBasedOnMembers, omitSamePlatforms, parentPlatforms) @@ -736,12 +744,6 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendSignatures(sign, members, platformsBasedOnMembers, omitSamePlatforms, parentPlatforms) } } - - val platformsToAppend = effectivePlatformAndVersion(nodes) - appendAsPlatformDependentBlock(platformsToAppend) { - appendContent(summary) - appendSoftLineBreak() - } } } -- cgit From 51cb9c12e4db76a552ada7445b346fe1ac3e68ef Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Thu, 27 Sep 2018 18:24:00 +0300 Subject: Remove implied platforms --- core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index d2321ad9..1a674626 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -129,10 +129,7 @@ open class KotlinWebsiteHtmlOutputBuilder( val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion)?.removePrefix("Kotlin ") val jreVersion = platforms.singleOrNull(String::isJREVersion) - val targetPlatforms = - platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } - .takeUnless { it.intersect(impliedPlatforms).containsAll(impliedPlatforms) } - .orEmpty() + val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } return mapOf( "platform" to targetPlatforms, -- cgit From 45495ebb61964ce853c4f1b5a4b63f28e18daa57 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Fri, 28 Sep 2018 20:10:45 +0300 Subject: Support new platform tags style --- .../Formats/KotlinWebsiteHtmlFormatService.kt | 38 +++--- .../main/kotlin/Formats/StructuredFormatService.kt | 148 +++++++++++++++------ 2 files changed, 126 insertions(+), 60 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 1a674626..5bd346da 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -69,27 +69,29 @@ open class KotlinWebsiteHtmlOutputBuilder( override fun appendLink(href: String, body: () -> Unit) = wrap("", "", body) override fun appendTable(vararg columns: String, body: () -> Unit) { - to.appendln("") - body() - to.appendln("
") + //to.appendln("") + div(to, "api-declarations-list") { + body() + } + //to.appendln("
") } override fun appendTableBody(body: () -> Unit) { - to.appendln("") + //to.appendln("") body() - to.appendln("") + //to.appendln("") } override fun appendTableRow(body: () -> Unit) { - to.appendln("") + //to.appendln("") body() - to.appendln("") + //to.appendln("") } override fun appendTableCell(body: () -> Unit) { - to.appendln("") +// to.appendln("") body() - to.appendln("\n") +// to.appendln("\n") } override fun appendSymbol(text: String) { @@ -125,12 +127,11 @@ open class KotlinWebsiteHtmlOutputBuilder( private fun calculatePlatforms(platforms: Set): Map> { fun String.isKotlinVersion() = this.startsWith("Kotlin") - fun String.isJREVersion() = this.startsWith("JRE") + fun String.isJREVersion() = this.startsWith("JRE", ignoreCase=true) val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion)?.removePrefix("Kotlin ") - val jreVersion = platforms.singleOrNull(String::isJREVersion) + val jreVersion = platforms.filter(String::isJREVersion).min()?.takeUnless { it.endsWith("6") } val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } - return mapOf( "platform" to targetPlatforms, "kotlin-version" to listOfNotNull(kotlinVersion), @@ -148,10 +149,13 @@ open class KotlinWebsiteHtmlOutputBuilder( } override fun appendIndexRow(platforms: Set, block: () -> Unit) { - if (platforms.isNotEmpty()) - wrap("", "", block) - else - appendTableRow(block) +// if (platforms.isNotEmpty()) +// wrap("", "", block) +// else +// appendTableRow(block) + div(to, "declarations", otherAttributes = " ${calculateDataAttributes(platforms)}") { + block() + } } override fun appendPlatforms(platforms: Set) { @@ -159,7 +163,7 @@ open class KotlinWebsiteHtmlOutputBuilder( div(to, "tags") { platformsToKind.entries.forEach { (kind, values) -> values.forEach { value -> - div(to, "tags__tag $kind") { + div(to, "tags__tag $kind tag-value-$value") { to.append(value) } } diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 162976a6..dabc0b2b 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -5,6 +5,48 @@ import java.util.* data class FormatLink(val text: String, val href: String) +private data class Summarized( + val data: List +) { + + constructor(data: Map>>) : this( + data.entries.map { (summary, signatureToMember) -> + SummarizedBySummary( + summary, + signatureToMember.map { (signature, nodes) -> + SummarizedNodes(signature, nodes) + } + ) + } + ) + + data class SummarizedNodes(val content: ContentNode, val nodes: List) { + val platforms = effectivePlatformAndVersion(nodes) + } + data class SummarizedBySummary(val content: ContentNode, val signatures: List) { + val platforms = effectivePlatformAndVersion(signatures.flatMap { it.nodes }) + val platformsOnSignature = !sameVersionAndPlatforms(signatures.map { it.platforms }) + } + + + fun computePlatformLevel(): PlatformPlacement { + if (data.any { it.platformsOnSignature }) { + return PlatformPlacement.Signature + } + if (sameVersionAndPlatforms(data.map { it.platforms })) { + return PlatformPlacement.Row + } + return PlatformPlacement.Summary + } + val platformPlacement: PlatformPlacement = computePlatformLevel() + val platforms = effectivePlatformAndVersion(data.flatMap { it.signatures.flatMap { it.nodes } }) + + + enum class PlatformPlacement { + Row, Summary, Signature + } +} + abstract class StructuredOutputBuilder(val to: StringBuilder, val location: Location, val generator: NodeLocationAwareGenerator, @@ -454,7 +496,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (platforms.isEmpty()) return appendParagraph { - appendStrong { to.append("Platform and version requirements:") } + appendStrong { to.append("WTF: Platform and version requirements:") } to.append(" " + platforms.joinToString()) } } @@ -678,20 +720,27 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendTable("Name", "Summary") { appendTableBody { for ((memberLocation, members) in membersMap) { - val platforms = emptySet() + val platforms = effectivePlatformAndVersion(members) // val platforms = if (platformsBasedOnMembers) // members.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms // else // elementPlatforms + + val summarized = computeSummarySignatures(members) + + appendIndexRow(platforms) { appendTableCell { + if (summarized.platformPlacement == Summarized.PlatformPlacement.Row) { + appendPlatforms(platforms) + } appendParagraph { appendLink(memberLocation) // if (members.singleOrNull()?.kind != NodeKind.ExternalClass) { // appendPlatforms(platforms) // } } - appendSummarySignatures(members, platformsBasedOnMembers, omitSamePlatforms, platforms) + appendSummarySignatures(summarized) } } } @@ -712,47 +761,52 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, // return emptySet() // } + + + private fun computeSummarySignatures(items: List): Summarized = + Summarized(items.groupBy { it.summary }.mapValues { (_, nodes) -> + val nodesToAppend = if (nodes.all { it.kind == NodeKind.GroupNode }) { + nodes.flatMap { it.origins } + } else { + nodes + } + val summarySignature = languageService.summarizeSignatures(nodesToAppend) + if (summarySignature != null) { + mapOf(summarySignature to nodes) + } else { + nodesToAppend.groupBy { + languageService.render(it, RenderMode.SUMMARY) + } + } + }) + + private fun appendSummarySignatures( - items: List, - platformsBasedOnMembers: Boolean, - omitSamePlatforms: Boolean, - parentPlatforms: Set + summarized: Summarized ) { - val groupBySummary = items.groupBy { it.summary } + for(summary in summarized.data) { - for ((summary, nodes) in groupBySummary) { - val nodesToAppend = if (nodes.all { it.kind == NodeKind.GroupNode }) { - nodes.flatMap { it.origins } - } else { - nodes - } - val platformsToAppend = effectivePlatformAndVersion(nodes) - appendAsPlatformDependentBlock(platformsToAppend) { - appendContent(summary) - appendSoftLineBreak() - } - val summarySignature = languageService.summarizeSignatures(nodesToAppend) - if (summarySignature != null) { - appendSignatures(summarySignature, nodes, platformsBasedOnMembers, omitSamePlatforms, parentPlatforms) - } else { - val groupBySignature = nodesToAppend.groupBy { - languageService.render(it, RenderMode.SUMMARY) - } - for ((sign, members) in groupBySignature) { - appendSignatures(sign, members, platformsBasedOnMembers, omitSamePlatforms, parentPlatforms) + appendAsPlatformDependentBlock(summary.platforms) { + if (summarized.platformPlacement == Summarized.PlatformPlacement.Summary) { + appendPlatforms(summary.platforms) } + appendContent(summary.content) + appendSoftLineBreak() + } + for (signature in summary.signatures) { + appendSignatures( + signature, + summarized.platformPlacement == Summarized.PlatformPlacement.Signature + ) } } } private fun appendSignatures( - signature: ContentNode, - items: List, - platformsBasedOnMembers: Boolean, - omitSamePlatforms: Boolean, - parentPlatforms: Set + signature: Summarized.SummarizedNodes, + withPlatforms: Boolean ) { // val platforms = if (platformsBasedOnMembers) @@ -760,14 +814,15 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, // else // elementPlatforms - val platformsToAppend = effectivePlatformAndVersion(items) - appendAsPlatformDependentBlock(platformsToAppend) { - appendAsSignature(signature) { - signature.appendSignature() + appendAsPlatformDependentBlock(signature.platforms) { + if (withPlatforms) { + appendPlatforms(signature.platforms) + } + appendAsSignature(signature.content) { + signature.content.appendSignature() } appendSoftLineBreak() - appendPlatforms(platformsToAppend) } } } @@ -859,7 +914,7 @@ fun effectivePlatformsForNode(node: DocumentationNode): Set { } } -fun effectivePlatformsForMembers(nodes: List): Set { +fun effectivePlatformsForMembers(nodes: Collection): Set { return nodes.map { effectivePlatformsForNode(it) }.reduce { acc, set -> acc.union(set) } @@ -889,18 +944,25 @@ fun effectiveSinceKotlinForNode(node: DocumentationNode, baseVersion: String = " val nodeVersion = node.sinceKotlin ?: baseVersion val memberVersion = if (members.isNotEmpty()) effectiveSinceKotlinForNodes(members, nodeVersion) else nodeVersion - println("${node.path} > $nodeVersion, $memberVersion") - return mergeVersions(listOf(memberVersion, nodeVersion)) } -fun effectiveSinceKotlinForNodes(nodes: List, baseVersion: String = "1.0"): String { +fun effectiveSinceKotlinForNodes(nodes: Collection, baseVersion: String = "1.0"): String { return mergeVersions(nodes.map { effectiveSinceKotlinForNode(it, baseVersion) }) } fun sinceKotlinAsPlatform(version: String): String = "Kotlin $version" -fun effectivePlatformAndVersion(nodes: List, baseVersion: String = "1.0"): Set { +fun effectivePlatformAndVersion(nodes: Collection, baseVersion: String = "1.0"): Set { return effectivePlatformsForMembers(nodes) + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(nodes, baseVersion)) } + +fun effectivePlatformAndVersion(node: DocumentationNode, baseVersion: String = "1.0"): Set { + return effectivePlatformsForNode(node) + sinceKotlinAsPlatform(effectiveSinceKotlinForNode(node, baseVersion)) +} + +fun sameVersionAndPlatforms(platformsPerNode: Collection>): Boolean { + val first = platformsPerNode.firstOrNull() ?: return true + return platformsPerNode.all { it == first } +} \ No newline at end of file -- cgit From c3b0ede82b925517e4c4859388ae4c7129d29a0d Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Fri, 28 Sep 2018 23:32:30 +0300 Subject: Remove concept of 'Plus' versions --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index dabc0b2b..fffa9e3e 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -921,16 +921,7 @@ fun effectivePlatformsForMembers(nodes: Collection): Set): String { - val allKotlinVersions = kotlinVersions.distinct() - - val minVersion = allKotlinVersions.min()!! - val resultVersion: String = when { - allKotlinVersions.size == 1 -> allKotlinVersions.single() - minVersion.endsWith("+") -> minVersion - else -> "$minVersion+" - } - - return resultVersion + return kotlinVersions.distinct().min()!! } fun effectiveSinceKotlinForNode(node: DocumentationNode, baseVersion: String = "1.0"): String { -- cgit From 25381f71922b8aa665e8c9ceaca58785237cfdba Mon Sep 17 00:00:00 2001 From: aleksZubakov Date: Mon, 1 Oct 2018 21:24:12 +0300 Subject: Fixed duplicated descriptions --- .../main/kotlin/Formats/StructuredFormatService.kt | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index fffa9e3e..7e21c30c 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -384,9 +384,8 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, val platforms = effectivePlatformsForMembers(origins) appendAsPlatformDependentBlock(platforms) { appendPlatforms(platforms) - appendParagraph { - appendContent(content) - } + appendContent(content.summary) + content.appendDescription() } } } else { @@ -394,12 +393,11 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, val platforms = effectivePlatformsForNode(item) appendAsPlatformDependentBlock(platforms) { appendPlatforms(platforms) - appendContent(item.content) + appendContent(item.summary) + item.content.appendDescription() } } } - - item.appendDescription() } @@ -561,15 +559,17 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, // val DocumentationNode.platformsToShow: List // get() = platforms - private fun DocumentationNode.appendDescription() { - if (content.description != ContentEmpty) { - appendContent(content.description) + private fun Content.appendDescription() { + if (description != ContentEmpty) { + appendContent(description) } - content.getSectionsWithSubjects().forEach { + + + getSectionsWithSubjects().forEach { appendSectionWithSubject(it.key, it.value) } - for (section in content.sections.filter { it.subjectName == null }) { + for (section in sections.filter { it.subjectName == null }) { appendSectionWithTag(section) } } -- cgit From 0741416fc19add9f83f3754eb99550b3c3578cf9 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Tue, 2 Oct 2018 03:21:11 +0300 Subject: Fix summarizing --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 7e21c30c..eda85031 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -765,14 +765,11 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, private fun computeSummarySignatures(items: List): Summarized = Summarized(items.groupBy { it.summary }.mapValues { (_, nodes) -> - val nodesToAppend = if (nodes.all { it.kind == NodeKind.GroupNode }) { - nodes.flatMap { it.origins } - } else { - nodes - } + val nodesToAppend = nodes.flatMap { if(it.kind == NodeKind.GroupNode) it.origins else listOf(it) } + val summarySignature = languageService.summarizeSignatures(nodesToAppend) if (summarySignature != null) { - mapOf(summarySignature to nodes) + mapOf(summarySignature to nodesToAppend) } else { nodesToAppend.groupBy { languageService.render(it, RenderMode.SUMMARY) -- cgit From 0f19897ef9de71f571b1af703ac33923640cb547 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Tue, 2 Oct 2018 03:23:01 +0300 Subject: Fix single node & group node pages platform display --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index eda85031..67e8c503 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -392,7 +392,6 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (!item.content.isEmpty()) { val platforms = effectivePlatformsForNode(item) appendAsPlatformDependentBlock(platforms) { - appendPlatforms(platforms) appendContent(item.summary) item.content.appendDescription() } @@ -409,13 +408,13 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (item.kind !in NodeKind.classLike || !isSingleNode) appendAnchor(it.name) } + appendPlatforms(platforms) appendAsSignature(rendered) { appendCode { appendContent(rendered) } item.appendSourceLink() } item.appendOverrides() item.appendDeprecation() - appendPlatforms(platforms) } } @@ -433,10 +432,11 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendAnchor(it.name) } + appendPlatforms(platforms) + appendAsSignature(sign) { appendCode { appendContent(sign) } } - appendPlatforms(platforms) first.appendOverrides() first.appendDeprecation() } @@ -611,11 +611,13 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, renderGroupNode(node, true) - for ((content, origins) in node.origins.groupBy { it.content }) { + val groupByContent = node.origins.groupBy { it.content } + for ((content, origins) in groupByContent) { if (content.isEmpty()) continue - val platforms = effectivePlatformAndVersion(origins) - appendAsPlatformDependentBlock(platforms) { - appendPlatforms(platforms) + appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> + if (groupByContent.keys.count { !it.isEmpty() } > 1) { + appendPlatforms(platforms) + } appendContent(content) } } -- cgit From 52d3e0e0de74c951651b6f3c9970d0ded7e15e1a Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Tue, 2 Oct 2018 16:19:05 +0300 Subject: Fix platform display for group node overloads --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 67e8c503..764fd50e 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -379,11 +379,13 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } if (item.kind == NodeKind.GroupNode) { - for ((content, origins) in item.origins.groupBy { it.content }) { + val groupByContent = item.origins.groupBy { it.content } + for ((content, origins) in groupByContent) { if (content.isEmpty()) continue - val platforms = effectivePlatformsForMembers(origins) - appendAsPlatformDependentBlock(platforms) { - appendPlatforms(platforms) + appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> + if (groupByContent.count { !it.key.isEmpty() } > 1) { + appendPlatforms(platforms) + } appendContent(content.summary) content.appendDescription() } -- cgit From 5c3007bfdcdaed03167a2b7997df6a98da397aaf Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 03:33:24 +0300 Subject: Fix yaml outline generation to use relative paths --- core/src/main/kotlin/Formats/YamlOutlineService.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/YamlOutlineService.kt b/core/src/main/kotlin/Formats/YamlOutlineService.kt index c36f98eb..3c92d8ff 100644 --- a/core/src/main/kotlin/Formats/YamlOutlineService.kt +++ b/core/src/main/kotlin/Formats/YamlOutlineService.kt @@ -13,7 +13,7 @@ class YamlOutlineService @Inject constructor( override fun appendOutlineHeader(location: Location, node: DocumentationNode, to: StringBuilder) { val indent = " ".repeat(outlineLevel) to.appendln("$indent- title: ${languageService.renderName(node)}") - to.appendln("$indent url: ${generator.location(node).path}") + to.appendln("$indent url: ${generator.relativePathToLocation(node.path.first(), node)}") } override fun appendOutlineLevel(to: StringBuilder, body: () -> Unit) { -- cgit From 2f377659e7b5251dceb4df3a6a25fe922edf28c6 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 03:57:49 +0300 Subject: Use spacer to align tags to right --- core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt | 1 + 1 file changed, 1 insertion(+) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 5bd346da..220f2f4d 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -161,6 +161,7 @@ open class KotlinWebsiteHtmlOutputBuilder( override fun appendPlatforms(platforms: Set) { val platformsToKind = calculatePlatforms(platforms) div(to, "tags") { + div(to, "spacer") {} platformsToKind.entries.forEach { (kind, values) -> values.forEach { value -> div(to, "tags__tag $kind tag-value-$value") { -- cgit From 896776306e15f1e5bbdc771a3e58d0ffd8b45198 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 03:59:57 +0300 Subject: Introduce block for grouped by summary items --- .../Formats/KotlinWebsiteHtmlFormatService.kt | 6 ++++++ .../main/kotlin/Formats/StructuredFormatService.kt | 21 ++++++++++++--------- 2 files changed, 18 insertions(+), 9 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 220f2f4d..65c93e72 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -206,6 +206,12 @@ open class KotlinWebsiteHtmlOutputBuilder( else block(platforms) } + + override fun appendAsSummaryGroup(platforms: Set, block: (Set) -> Unit) { + div(to, "summary-group", otherAttributes = " ${calculateDataAttributes(platforms)}") { + block(platforms) + } + } } class KotlinWebsiteHtmlFormatService @Inject constructor( diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 764fd50e..647f2dfb 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -129,6 +129,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, block(platforms) } + open fun appendAsSummaryGroup(platforms: Set, block: (Set) -> Unit) { + appendAsPlatformDependentBlock(platforms, block) + } + open fun appendSymbol(text: String) { appendText(text) } @@ -787,21 +791,20 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, ) { for(summary in summarized.data) { - - - appendAsPlatformDependentBlock(summary.platforms) { + appendAsSummaryGroup(summary.platforms) { if (summarized.platformPlacement == Summarized.PlatformPlacement.Summary) { appendPlatforms(summary.platforms) } appendContent(summary.content) appendSoftLineBreak() + for (signature in summary.signatures) { + appendSignatures( + signature, + summarized.platformPlacement == Summarized.PlatformPlacement.Signature + ) + } } - for (signature in summary.signatures) { - appendSignatures( - signature, - summarized.platformPlacement == Summarized.PlatformPlacement.Signature - ) - } + } } -- cgit From 5719e5c5f7d90aa606421381a0e4e4ffbf1b9066 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 04:09:09 +0300 Subject: Append notices platforms as header instead of tags --- .../main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt | 15 +++++++++++---- core/src/main/kotlin/Formats/StructuredFormatService.kt | 11 +++++++++-- 2 files changed, 20 insertions(+), 6 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 65c93e72..9ffefcab 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -125,10 +125,6 @@ open class KotlinWebsiteHtmlOutputBuilder( } private fun calculatePlatforms(platforms: Set): Map> { - - fun String.isKotlinVersion() = this.startsWith("Kotlin") - fun String.isJREVersion() = this.startsWith("JRE", ignoreCase=true) - val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion)?.removePrefix("Kotlin ") val jreVersion = platforms.filter(String::isJREVersion).min()?.takeUnless { it.endsWith("6") } val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } @@ -176,6 +172,13 @@ open class KotlinWebsiteHtmlOutputBuilder( to.append(" / ") } + override fun appendPlatformsAsText(platforms: Set) { + appendHeader(5) { + to.append("For ") + platforms.filterNot { it.isJREVersion() }.joinTo(to) + } + } + override fun appendSampleBlockCode(language: String, imports: () -> Unit, body: () -> Unit) { div(to, "sample") { appendBlockCode(language) { @@ -226,3 +229,7 @@ class KotlinWebsiteHtmlFormatService @Inject constructor( override fun createOutputBuilder(to: StringBuilder, location: Location) = KotlinWebsiteHtmlOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms, templateService) } + + +private fun String.isKotlinVersion() = this.startsWith("Kotlin") +private fun String.isJREVersion() = this.startsWith("JRE", ignoreCase=true) \ No newline at end of file diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 647f2dfb..4496d652 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -281,6 +281,13 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendTableRow(block) } + protected open fun appendPlatformsAsText(platforms: Set) { + if (platforms.isNotEmpty()) { + appendLine() + appendText(platforms.joinToString(prefix = "(", postfix = ")")) + } + } + protected open fun appendPlatforms(platforms: Set) { if (platforms.isNotEmpty()) { appendLine() @@ -388,7 +395,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (content.isEmpty()) continue appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> if (groupByContent.count { !it.key.isEmpty() } > 1) { - appendPlatforms(platforms) + appendPlatformsAsText(platforms) } appendContent(content.summary) content.appendDescription() @@ -622,7 +629,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (content.isEmpty()) continue appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> if (groupByContent.keys.count { !it.isEmpty() } > 1) { - appendPlatforms(platforms) + appendPlatformsAsText(platforms) } appendContent(content) } -- cgit From be3e435500246b971ac12ffccad9d11417f4717c Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 04:16:47 +0300 Subject: Wrap node's own description on full page into block --- .../Formats/KotlinWebsiteHtmlFormatService.kt | 7 ++++++ .../main/kotlin/Formats/StructuredFormatService.kt | 27 ++++++++++++++-------- 2 files changed, 25 insertions(+), 9 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 9ffefcab..c412b34e 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -168,6 +168,13 @@ open class KotlinWebsiteHtmlOutputBuilder( } } + override fun appendAsNodeDescription(platforms: Set, block: () -> Unit) { + div(to, "node-page-main", otherAttributes = " ${calculateDataAttributes(platforms)}") { + block() + } + + } + override fun appendBreadcrumbSeparator() { to.append(" / ") } diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 4496d652..67a2f293 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -145,6 +145,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendText(text) } + open fun appendAsNodeDescription(platforms: Set, block: () -> Unit) { + block() + } + fun appendEntity(text: String) { to.append(text) } @@ -361,7 +365,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } if (breakdownBySummary.size == 1) { - formatOverloadGroup(breakdownBySummary.values.single(), isSingleNode) + val node = breakdownBySummary.values.single() + appendAsNodeDescription(effectivePlatformAndVersion(node)) { + formatOverloadGroup(node, isSingleNode) + } } else { for ((_, items) in breakdownBySummary) { appendAsOverloadGroup(to, effectivePlatformAndVersion(items)) { @@ -622,16 +629,18 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendLine() appendHeader { appendText(node.name) } - renderGroupNode(node, true) + appendAsNodeDescription(effectivePlatformAndVersion(node)) { + renderGroupNode(node, true) - val groupByContent = node.origins.groupBy { it.content } - for ((content, origins) in groupByContent) { - if (content.isEmpty()) continue - appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> - if (groupByContent.keys.count { !it.isEmpty() } > 1) { - appendPlatformsAsText(platforms) + val groupByContent = node.origins.groupBy { it.content } + for ((content, origins) in groupByContent) { + if (content.isEmpty()) continue + appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> + if (groupByContent.keys.count { !it.isEmpty() } > 1) { + appendPlatformsAsText(platforms) + } + appendContent(content) } - appendContent(content) } } -- cgit From aee7a8e76f2d593a6ba73db1f475acca68b7d693 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 04:18:03 +0300 Subject: Don't show platforms on package and module pages --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 12 ------------ 1 file changed, 12 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 67a2f293..e12a7923 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -344,7 +344,6 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, val packageName = if (singleNode.name.isEmpty()) "" else singleNode.name appendHeader(2) { appendText("Package $packageName") } } - singleNode.appendPlatforms() appendContent(singleNode.content) } else { val breakdownByName = nodes.groupBy { node -> node.name } @@ -509,18 +508,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } - private fun DocumentationNode.appendPlatforms() { - val platforms = actualPlatforms - if (platforms.isEmpty()) return - appendParagraph { - appendStrong { to.append("WTF: Platform and version requirements:") } - to.append(" " + platforms.joinToString()) - } - } - - val DocumentationNode.actualPlatforms: Collection - get() = effectivePlatformAndVersion(listOf(this)) // protected fun platformsOfItems(items: List): Set { -- cgit From 7b1020e2d413602a36b69071385e6b4f406961f3 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 04:20:22 +0300 Subject: Render platforms on overload group level if platforms are similar --- .../main/kotlin/Formats/StructuredFormatService.kt | 27 +++++++++++++++++----- 1 file changed, 21 insertions(+), 6 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index e12a7923..8b66f187 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -378,13 +378,24 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } private fun formatOverloadGroup(items: List, isSingleNode: Boolean = false) { + + val platformsPerGroup = sameVersionAndPlatforms( + items.flatMap { if (it.kind == NodeKind.GroupNode) it.origins else listOf(it) } + .map { effectivePlatformAndVersion(it) } + ) + + if (platformsPerGroup) { + appendAsPlatformDependentBlock(effectivePlatformAndVersion(items)) { platforms -> + appendPlatforms(platforms) + } + } for ((index, item) in items.withIndex()) { if (index > 0) appendLine() if (item.kind == NodeKind.GroupNode) { - renderGroupNode(item, isSingleNode) + renderGroupNode(item, isSingleNode, !platformsPerGroup) } else { - renderSimpleNode(item, isSingleNode) + renderSimpleNode(item, isSingleNode, !platformsPerGroup) } } @@ -419,7 +430,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } - fun renderSimpleNode(item: DocumentationNode, isSingleNode: Boolean) { + fun renderSimpleNode(item: DocumentationNode, isSingleNode: Boolean, withPlatforms: Boolean = true) { appendAsPlatformDependentBlock(effectivePlatformAndVersion(listOf(item))) { platforms -> // TODO: use summarizesignatures val rendered = languageService.render(item) @@ -427,7 +438,9 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (item.kind !in NodeKind.classLike || !isSingleNode) appendAnchor(it.name) } - appendPlatforms(platforms) + if (withPlatforms) { + appendPlatforms(platforms) + } appendAsSignature(rendered) { appendCode { appendContent(rendered) } item.appendSourceLink() @@ -437,7 +450,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } - fun renderGroupNode(item: DocumentationNode, isSingleNode: Boolean) { + fun renderGroupNode(item: DocumentationNode, isSingleNode: Boolean, withPlatforms: Boolean = true) { // TODO: use summarizesignatures val groupBySignature = item.origins.groupBy { languageService.render(it) @@ -451,7 +464,9 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendAnchor(it.name) } - appendPlatforms(platforms) + if (withPlatforms) { + appendPlatforms(platforms) + } appendAsSignature(sign) { appendCode { appendContent(sign) } -- cgit From eca90bfabc21a89b0d9ce40d2590c9383623ab79 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 08:02:17 +0300 Subject: Track sinceKotlin per platform and other attributes as well --- .../kotlin/Formats/KotlinWebsiteFormatService.kt | 10 +- .../Formats/KotlinWebsiteHtmlFormatService.kt | 63 ++++++------ .../main/kotlin/Formats/StructuredFormatService.kt | 106 ++++++++++----------- 3 files changed, 87 insertions(+), 92 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteFormatService.kt index a98002d4..51ceb47e 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteFormatService.kt @@ -57,8 +57,8 @@ open class KotlinWebsiteOutputBuilder( } } - override fun appendAsOverloadGroup(to: StringBuilder, platforms: Set, block: () -> Unit) { - div(to, "overload-group", calculateDataAttributes(platforms), true) { + override fun appendAsOverloadGroup(to: StringBuilder, platforms: PlatformsData, block: () -> Unit) { + div(to, "overload-group", calculateDataAttributes(platforms.keys), true) { ensureParagraph() block() ensureParagraph() @@ -159,14 +159,14 @@ open class KotlinWebsiteOutputBuilder( return "$platformsAttr$kotlinVersionAttr$jreVersionAttr" } - override fun appendIndexRow(platforms: Set, block: () -> Unit) { + override fun appendIndexRow(platforms: PlatformsData, block: () -> Unit) { if (platforms.isNotEmpty()) - wrap("", "", block) + wrap("", "", block) else appendTableRow(block) } - override fun appendPlatforms(platforms: Set) { + override fun appendPlatforms(platforms: PlatformsData) { } } diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index c412b34e..b12075fb 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -3,7 +3,6 @@ package org.jetbrains.dokka import com.google.inject.Inject import com.google.inject.name.Named import org.jetbrains.dokka.Utilities.impliedPlatformsName -import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty import java.io.File @@ -60,7 +59,7 @@ open class KotlinWebsiteHtmlOutputBuilder( } } - override fun appendAsOverloadGroup(to: StringBuilder, platforms: Set, block: () -> Unit) { + override fun appendAsOverloadGroup(to: StringBuilder, platforms: PlatformsData, block: () -> Unit) { div(to, "overload-group", calculateDataAttributes(platforms)) { block() } @@ -124,27 +123,29 @@ open class KotlinWebsiteHtmlOutputBuilder( else -> "identifier" } - private fun calculatePlatforms(platforms: Set): Map> { - val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion)?.removePrefix("Kotlin ") - val jreVersion = platforms.filter(String::isJREVersion).min()?.takeUnless { it.endsWith("6") } - val targetPlatforms = platforms.filterNot { it.isKotlinVersion() || it.isJREVersion() } - return mapOf( - "platform" to targetPlatforms, - "kotlin-version" to listOfNotNull(kotlinVersion), - "jre-version" to listOfNotNull(jreVersion) + private data class PlatformsForElement( + val platformToVersion: Map + ) + + private fun calculatePlatforms(platforms: PlatformsData): PlatformsForElement { + //val kotlinVersion = platforms.singleOrNull(String::isKotlinVersion)?.removePrefix("Kotlin ") + val jreVersion = platforms.keys.filter(String::isJREVersion).min()?.takeUnless { it.endsWith("6") } + val targetPlatforms = platforms.filterNot { it.key.isJREVersion() } + + listOfNotNull(jreVersion?.let { it to platforms[it]!! }) + + return PlatformsForElement( + targetPlatforms.mapValues { (_, nodes) -> effectiveSinceKotlinForNodes(nodes) } ) } - private fun calculateDataAttributes(platforms: Set): String { - val platformsByKind = calculatePlatforms(platforms) - return platformsByKind - .entries.filterNot { it.value.isEmpty() } - .joinToString(separator = " ") { (kind, values) -> - "data-$kind=\"${values.joinToString()}\"" - } + private fun calculateDataAttributes(platforms: PlatformsData): String { + val platformToVersion = calculatePlatforms(platforms).platformToVersion + val (platformNames, versions) = platformToVersion.toList().unzip() + return "data-platform=\"${platformNames.joinToString()}\" "+ + "data-kotlin-version=\"${versions.joinToString()}\"" } - override fun appendIndexRow(platforms: Set, block: () -> Unit) { + override fun appendIndexRow(platforms: PlatformsData, block: () -> Unit) { // if (platforms.isNotEmpty()) // wrap("", "", block) // else @@ -154,21 +155,23 @@ open class KotlinWebsiteHtmlOutputBuilder( } } - override fun appendPlatforms(platforms: Set) { - val platformsToKind = calculatePlatforms(platforms) + override fun appendPlatforms(platforms: PlatformsData) { + val platformToVersion = calculatePlatforms(platforms).platformToVersion div(to, "tags") { div(to, "spacer") {} - platformsToKind.entries.forEach { (kind, values) -> - values.forEach { value -> - div(to, "tags__tag $kind tag-value-$value") { - to.append(value) - } + platformToVersion.entries.forEach { (platform, version) -> + div(to, "tags__tag platform tag-value-$platform", + otherAttributes = " data-tag-version=\"$version\"") { + to.append(platform) } } + div(to, "tags__tag kotlin-version") { + to.append(mergeVersions(platformToVersion.values.toList())) + } } } - override fun appendAsNodeDescription(platforms: Set, block: () -> Unit) { + override fun appendAsNodeDescription(platforms: PlatformsData, block: () -> Unit) { div(to, "node-page-main", otherAttributes = " ${calculateDataAttributes(platforms)}") { block() } @@ -179,10 +182,10 @@ open class KotlinWebsiteHtmlOutputBuilder( to.append(" / ") } - override fun appendPlatformsAsText(platforms: Set) { + override fun appendPlatformsAsText(platforms: PlatformsData) { appendHeader(5) { to.append("For ") - platforms.filterNot { it.isJREVersion() }.joinTo(to) + platforms.keys.filterNot { it.isJREVersion() }.joinTo(to) } } @@ -208,7 +211,7 @@ open class KotlinWebsiteHtmlOutputBuilder( } } - override fun appendAsPlatformDependentBlock(platforms: Set, block: (Set) -> Unit) { + override fun appendAsPlatformDependentBlock(platforms: PlatformsData, block: (PlatformsData) -> Unit) { if (platforms.isNotEmpty()) wrap("
", "
") { block(platforms) @@ -217,7 +220,7 @@ open class KotlinWebsiteHtmlOutputBuilder( block(platforms) } - override fun appendAsSummaryGroup(platforms: Set, block: (Set) -> Unit) { + override fun appendAsSummaryGroup(platforms: PlatformsData, block: (PlatformsData) -> Unit) { div(to, "summary-group", otherAttributes = " ${calculateDataAttributes(platforms)}") { block(platforms) } diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 8b66f187..98414695 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -1,6 +1,7 @@ package org.jetbrains.dokka import org.jetbrains.dokka.LanguageService.RenderMode +import org.jetbrains.kotlin.utils.keysToMap import java.util.* data class FormatLink(val text: String, val href: String) @@ -21,11 +22,11 @@ private data class Summarized( ) data class SummarizedNodes(val content: ContentNode, val nodes: List) { - val platforms = effectivePlatformAndVersion(nodes) + val platforms = effectivePlatformsForMembers(nodes) } data class SummarizedBySummary(val content: ContentNode, val signatures: List) { - val platforms = effectivePlatformAndVersion(signatures.flatMap { it.nodes }) - val platformsOnSignature = !sameVersionAndPlatforms(signatures.map { it.platforms }) + val platforms = effectivePlatformsForMembers(signatures.flatMap { it.nodes }) + val platformsOnSignature = !samePlatforms(signatures.map { it.platforms }) } @@ -33,13 +34,13 @@ private data class Summarized( if (data.any { it.platformsOnSignature }) { return PlatformPlacement.Signature } - if (sameVersionAndPlatforms(data.map { it.platforms })) { + if (samePlatforms(data.map { it.platforms })) { return PlatformPlacement.Row } return PlatformPlacement.Summary } val platformPlacement: PlatformPlacement = computePlatformLevel() - val platforms = effectivePlatformAndVersion(data.flatMap { it.signatures.flatMap { it.nodes } }) + val platforms = effectivePlatformsForMembers(data.flatMap { it.signatures.flatMap { it.nodes } }) enum class PlatformPlacement { @@ -125,11 +126,11 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } - open fun appendAsPlatformDependentBlock(platforms: Set, block: (Set) -> Unit) { + open fun appendAsPlatformDependentBlock(platforms: PlatformsData, block: (PlatformsData) -> Unit) { block(platforms) } - open fun appendAsSummaryGroup(platforms: Set, block: (Set) -> Unit) { + open fun appendAsSummaryGroup(platforms: PlatformsData, block: (PlatformsData) -> Unit) { appendAsPlatformDependentBlock(platforms, block) } @@ -145,7 +146,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendText(text) } - open fun appendAsNodeDescription(platforms: Set, block: () -> Unit) { + open fun appendAsNodeDescription(platforms: PlatformsData, block: () -> Unit) { block() } @@ -277,25 +278,25 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, block() } - protected open fun appendAsOverloadGroup(to: StringBuilder, platforms: Set, block: () -> Unit) { + protected open fun appendAsOverloadGroup(to: StringBuilder, platforms: PlatformsData, block: () -> Unit) { block() } - protected open fun appendIndexRow(platforms: Set, block: () -> Unit) { + protected open fun appendIndexRow(platforms: PlatformsData, block: () -> Unit) { appendTableRow(block) } - protected open fun appendPlatformsAsText(platforms: Set) { + protected open fun appendPlatformsAsText(platforms: PlatformsData) { if (platforms.isNotEmpty()) { appendLine() - appendText(platforms.joinToString(prefix = "(", postfix = ")")) + appendText(platforms.keys.joinToString(prefix = "(", postfix = ")")) } } - protected open fun appendPlatforms(platforms: Set) { + protected open fun appendPlatforms(platforms: PlatformsData) { if (platforms.isNotEmpty()) { appendLine() - appendText(platforms.joinToString(prefix = "(", postfix = ")")) + appendText(platforms.keys.joinToString(prefix = "(", postfix = ")")) } } @@ -358,19 +359,19 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, private fun appendDocumentation(overloads: Iterable, isSingleNode: Boolean) { val breakdownBySummary = overloads.groupByTo(LinkedHashMap()) { node -> when (node.kind) { - NodeKind.GroupNode -> node.origins.first().content + NodeKind.GroupNode -> node.origins.map { it.content } else -> node.content } } if (breakdownBySummary.size == 1) { val node = breakdownBySummary.values.single() - appendAsNodeDescription(effectivePlatformAndVersion(node)) { + appendAsNodeDescription(effectivePlatformsForMembers(node)) { formatOverloadGroup(node, isSingleNode) } } else { for ((_, items) in breakdownBySummary) { - appendAsOverloadGroup(to, effectivePlatformAndVersion(items)) { + appendAsOverloadGroup(to, effectivePlatformsForMembers(items)) { formatOverloadGroup(items) } } @@ -379,13 +380,13 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, private fun formatOverloadGroup(items: List, isSingleNode: Boolean = false) { - val platformsPerGroup = sameVersionAndPlatforms( + val platformsPerGroup = samePlatforms( items.flatMap { if (it.kind == NodeKind.GroupNode) it.origins else listOf(it) } - .map { effectivePlatformAndVersion(it) } + .map { effectivePlatformsForNode(it) } ) if (platformsPerGroup) { - appendAsPlatformDependentBlock(effectivePlatformAndVersion(items)) { platforms -> + appendAsPlatformDependentBlock(effectivePlatformsForMembers(items)) { platforms -> appendPlatforms(platforms) } } @@ -411,6 +412,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, for ((content, origins) in groupByContent) { if (content.isEmpty()) continue appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> + println("FOG_GN_MULTI(${groupByContent.count { !it.key.isEmpty() }}):" + item.path.joinToString(" > ")) if (groupByContent.count { !it.key.isEmpty() } > 1) { appendPlatformsAsText(platforms) } @@ -431,7 +433,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, fun renderSimpleNode(item: DocumentationNode, isSingleNode: Boolean, withPlatforms: Boolean = true) { - appendAsPlatformDependentBlock(effectivePlatformAndVersion(listOf(item))) { platforms -> + appendAsPlatformDependentBlock(effectivePlatformsForMembers(listOf(item))) { platforms -> // TODO: use summarizesignatures val rendered = languageService.render(item) item.detailOrNull(NodeKind.Signature)?.let { @@ -457,7 +459,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } for ((sign, nodes) in groupBySignature) { - appendAsPlatformDependentBlock(effectivePlatformAndVersion(nodes)) { platforms -> + appendAsPlatformDependentBlock(effectivePlatformsForMembers(nodes)) { platforms -> val first = nodes.first() first.detailOrNull(NodeKind.Signature)?.let { if (item.kind !in NodeKind.classLike || !isSingleNode) @@ -632,7 +634,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendLine() appendHeader { appendText(node.name) } - appendAsNodeDescription(effectivePlatformAndVersion(node)) { + appendAsNodeDescription(effectivePlatformsForNode(node)) { renderGroupNode(node, true) val groupByContent = node.origins.groupBy { it.content } @@ -747,7 +749,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendTable("Name", "Summary") { appendTableBody { for ((memberLocation, members) in membersMap) { - val platforms = effectivePlatformAndVersion(members) + val platforms = effectivePlatformsForMembers(members) // val platforms = if (platformsBasedOnMembers) // members.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms // else @@ -915,32 +917,32 @@ abstract class StructuredFormatService(val generator: NodeLocationAwareGenerator } +typealias PlatformsData = Map> -fun memberPlatforms(node: DocumentationNode): Sequence> { +fun memberPlatforms(node: DocumentationNode): PlatformsData { val members = when { node.kind == NodeKind.GroupNode -> node.origins else -> node.members } - return members.asSequence() - .map { effectivePlatformsForNode(it) } + return members.map(::effectivePlatformsForNode).fold(mapOf(), ::mergePlatforms) } -fun effectivePlatformsForNode(node: DocumentationNode): Set { - val platforms = - sequenceOf(node.platforms.toSet()) + memberPlatforms(node) - - - // Calculating common platforms for items - return platforms.reduce { result, platformsOfItem -> - result.union(platformsOfItem) +fun mergePlatforms(a: PlatformsData, b: PlatformsData): PlatformsData { + val mutable = a.toMutableMap() + b.forEach { (name, declarations) -> + mutable.merge(name, declarations) { a, b -> a.union(b) } } + return mutable } -fun effectivePlatformsForMembers(nodes: Collection): Set { - return nodes.map { effectivePlatformsForNode(it) }.reduce { acc, set -> - acc.union(set) - } +fun effectivePlatformsForNode(node: DocumentationNode): PlatformsData { + val platforms = node.platforms + memberPlatforms(node).keys + return platforms.keysToMap { setOf(node) } +} + +fun effectivePlatformsForMembers(nodes: Collection): PlatformsData { + return nodes.map { effectivePlatformsForNode(it) }.reduce(::mergePlatforms) } fun mergeVersions(kotlinVersions: List): String { @@ -954,29 +956,19 @@ fun effectiveSinceKotlinForNode(node: DocumentationNode, baseVersion: String = " node.kind in NodeKind.memberLike -> emptyList() else -> node.members } + val newBase = node.sinceKotlin ?: baseVersion + val memberVersion = if (members.isNotEmpty()) effectiveSinceKotlinForNodes(members, newBase) else newBase - val nodeVersion = node.sinceKotlin ?: baseVersion - val memberVersion = if (members.isNotEmpty()) effectiveSinceKotlinForNodes(members, nodeVersion) else nodeVersion - - return mergeVersions(listOf(memberVersion, nodeVersion)) + return node.sinceKotlin ?: memberVersion } fun effectiveSinceKotlinForNodes(nodes: Collection, baseVersion: String = "1.0"): String { - return mergeVersions(nodes.map { effectiveSinceKotlinForNode(it, baseVersion) }) + val map = nodes.map { effectiveSinceKotlinForNode(it, baseVersion) } + return mergeVersions(map) } -fun sinceKotlinAsPlatform(version: String): String = "Kotlin $version" - - -fun effectivePlatformAndVersion(nodes: Collection, baseVersion: String = "1.0"): Set { - return effectivePlatformsForMembers(nodes) + sinceKotlinAsPlatform(effectiveSinceKotlinForNodes(nodes, baseVersion)) -} - -fun effectivePlatformAndVersion(node: DocumentationNode, baseVersion: String = "1.0"): Set { - return effectivePlatformsForNode(node) + sinceKotlinAsPlatform(effectiveSinceKotlinForNode(node, baseVersion)) -} +fun samePlatforms(platformsPerNode: Collection): Boolean { -fun sameVersionAndPlatforms(platformsPerNode: Collection>): Boolean { - val first = platformsPerNode.firstOrNull() ?: return true - return platformsPerNode.all { it == first } + val first = platformsPerNode.firstOrNull()?.keys ?: return true + return platformsPerNode.all { it.keys == first } } \ No newline at end of file -- cgit From 810fce90353f044de1531a2cf5b340ff7732b083 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 22:25:11 +0300 Subject: Use headers instead of paragraphs for section declaration block title --- .../main/kotlin/Formats/StructuredFormatService.kt | 28 ++++++++++------------ 1 file changed, 12 insertions(+), 16 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 98414695..282ea7d6 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -763,7 +763,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (summarized.platformPlacement == Summarized.PlatformPlacement.Row) { appendPlatforms(platforms) } - appendParagraph { + appendHeader(level = 4) { appendLink(memberLocation) // if (members.singleOrNull()?.kind != NodeKind.ExternalClass) { // appendPlatforms(platforms) @@ -871,27 +871,23 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendTable("Name", "Summary") { appendTableBody { for (type in node.members) { - appendTableRow { - appendTableCell { + val platforms = effectivePlatformsForNode(type) + appendIndexRow(platforms) { + appendPlatforms(platforms) + appendHeader(level = 5) { appendLink(link(node, type) { if (it.kind == NodeKind.ExternalClass) it.name else it.qualifiedName() }) - if (type.kind == NodeKind.ExternalClass) { - val packageName = type.owner?.name - if (packageName != null) { - appendText(" (extensions in package $packageName)") - } - } } - appendTableCell { - val summary = if (type.isClassLikeGroupNode()) { - type.origins.first().summary - } else { - type.summary - } - appendContent(summary) + if (type.kind == NodeKind.ExternalClass) { + val packageName = type.owner?.name + if (packageName != null) { + appendText(" (extensions in package $packageName)") + } } + + appendContent(type.summary) } } } -- cgit From 234169e34e4362e598e1cecb50f116c8c1ea74d2 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Oct 2018 23:49:36 +0300 Subject: Fix platform merging on group by signature in overload group --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 282ea7d6..f989fad6 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -381,8 +381,15 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, private fun formatOverloadGroup(items: List, isSingleNode: Boolean = false) { val platformsPerGroup = samePlatforms( - items.flatMap { if (it.kind == NodeKind.GroupNode) it.origins else listOf(it) } - .map { effectivePlatformsForNode(it) } + items.flatMap { + if (it.kind == NodeKind.GroupNode) { + it.origins.groupBy { origin -> + languageService.render(origin) + }.values.map { origins -> effectivePlatformsForMembers(origins) } + } else { + listOf(effectivePlatformsForNode(it)) + } + } ) if (platformsPerGroup) { -- cgit From bf883d16819791f9ed66fda97560f5e2f02e7506 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Thu, 4 Oct 2018 06:42:59 +0300 Subject: Proper GroupNode members relocation condition --- core/src/main/kotlin/Formats/PackageListService.kt | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/PackageListService.kt b/core/src/main/kotlin/Formats/PackageListService.kt index 7b68098e..e675d927 100644 --- a/core/src/main/kotlin/Formats/PackageListService.kt +++ b/core/src/main/kotlin/Formats/PackageListService.kt @@ -32,10 +32,13 @@ class DefaultPackageListService @Inject constructor( node.members.forEach { visit(it, relocated = true) } } NodeKind.GroupNode -> { - //only children of top-level GN records interesting for us, since link to top-level ones should point to GN - node.members.forEach { it.members.forEach { visit(it, relocated = true) } } - //record signature of GN as signature of type alias and class merged to GN, so link to it should point to GN - node.detailOrNull(NodeKind.Signature)?.let { visit(it, relocated = true) } + if (node.members.isNotEmpty()) { + // Only nodes only has single file is need to be relocated + // TypeAliases for example + node.origins + .filter { it.members.isEmpty() } + .forEach { visit(it, relocated = true) } + } } else -> { if (nodeKind in NodeKind.classLike || nodeKind in NodeKind.memberLike) { -- cgit From cbed7d1899481ec60256d9e26d47d75a3974f9ef Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Thu, 4 Oct 2018 06:43:27 +0300 Subject: Hacky sort platforms on display --- .../kotlin/Formats/KotlinWebsiteHtmlFormatService.kt | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index b12075fb..3b2b2897 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -159,7 +159,9 @@ open class KotlinWebsiteHtmlOutputBuilder( val platformToVersion = calculatePlatforms(platforms).platformToVersion div(to, "tags") { div(to, "spacer") {} - platformToVersion.entries.forEach { (platform, version) -> + platformToVersion.entries.sortedBy { + platformSortWeight(it.key) + }.forEach { (platform, version) -> div(to, "tags__tag platform tag-value-$platform", otherAttributes = " data-tag-version=\"$version\"") { to.append(platform) @@ -184,8 +186,11 @@ open class KotlinWebsiteHtmlOutputBuilder( override fun appendPlatformsAsText(platforms: PlatformsData) { appendHeader(5) { - to.append("For ") - platforms.keys.filterNot { it.isJREVersion() }.joinTo(to) + val filtered = platforms.keys.filterNot { it.isJREVersion() }.sortedBy { platformSortWeight(it) } + if (filtered.isNotEmpty()) { + to.append("For ") + filtered.joinTo(to) + } } } @@ -225,6 +230,14 @@ open class KotlinWebsiteHtmlOutputBuilder( block(platforms) } } + + fun platformSortWeight(name: String) = when(name.toLowerCase()) { + "common" -> 0 + "jvm" -> 1 + "js" -> 3 + "native" -> 4 + else -> 2 // This is hack to support JRE/JUnit and so on + } } class KotlinWebsiteHtmlFormatService @Inject constructor( -- cgit From 712bb8ba9b146c769b84503e332fc449ff942141 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Thu, 4 Oct 2018 06:44:17 +0300 Subject: Take GroupNodes into account when computing node location --- .../main/kotlin/Formats/StructuredFormatService.kt | 75 ++++++++++++++-------- core/src/main/kotlin/Locations/Location.kt | 18 +++++- 2 files changed, 64 insertions(+), 29 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index f989fad6..33d26a93 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -55,8 +55,6 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, val extension: String, impliedPlatforms: List) : FormattedOutputBuilder { - protected fun DocumentationNode.location() = generator.location(this) - protected fun wrap(prefix: String, suffix: String, body: () -> Unit) { to.append(prefix) body() @@ -209,7 +207,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, is ContentNodeLink -> { val node = content.node - val linkTo = if (node != null) locationHref(location, node) else "#" + val linkTo = if (node != null) locationHref(location, node, generator) else "#" appendLinkIfNotThisPage(linkTo, content) } is ContentExternalLink -> appendLinkIfNotThisPage(content.href, content) @@ -259,17 +257,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, extension: String, name: (DocumentationNode) -> String = DocumentationNode::name ): FormatLink = - FormatLink(name(to), from.location().relativePathTo(to.location())) - - - fun locationHref(from: Location, to: DocumentationNode): String { - val topLevelPage = to.references(RefKind.TopLevelPage).singleOrNull()?.to - if (topLevelPage != null) { - val signature = to.detailOrNull(NodeKind.Signature) - return from.relativePathTo(topLevelPage.location(), signature?.name ?: to.name) - } - return from.relativePathTo(to.location()) - } + FormatLink(name(to), generator.relativePathToLocation(from, to)) private fun DocumentationNode.isModuleOrPackage(): Boolean = kind == NodeKind.Module || kind == NodeKind.Package @@ -467,6 +455,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, for ((sign, nodes) in groupBySignature) { appendAsPlatformDependentBlock(effectivePlatformsForMembers(nodes)) { platforms -> + println("GNPM: ${platforms.toList().joinToString { "${it.first}->${it.second.map { it.path.joinToString(separator = ">") }}" }}") val first = nodes.first() first.detailOrNull(NodeKind.Signature)?.let { if (item.kind !in NodeKind.classLike || !isSingleNode) @@ -499,7 +488,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, overrides.forEach { appendParagraph { to.append("Overrides ") - val location = location().relativePathTo(it.location()) + val location = generator.relativePathToLocation(this, it) appendLink(FormatLink(it.owner!!.name + "." + it.name, location)) } @@ -533,8 +522,6 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } - - // protected fun platformsOfItems(items: List): Set { // val platforms = items.asSequence().map { // when (it.kind) { @@ -620,6 +607,29 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, } } } + + fun appendOriginsGroupByContent(node: DocumentationNode) { + require(node.kind == NodeKind.GroupNode) + val groupByContent = + node.origins.groupBy { it.content } + .mapValues { (_, origins) -> + effectivePlatformsForMembers(origins) + } + .filterNot { it.key.isEmpty() } + .toList() + .sortedByDescending { it.second.size } + + + for ((content, platforms) in groupByContent) { + appendAsPlatformDependentBlock(platforms) { + if (groupByContent.size > 1) { + appendPlatformsAsText(platforms) + } + appendContent(content.summary) + content.appendDescription() + } + } + } } inner class SingleNodePageBuilder(val node: DocumentationNode, noHeader: Boolean = false) : @@ -644,18 +654,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendAsNodeDescription(effectivePlatformsForNode(node)) { renderGroupNode(node, true) - val groupByContent = node.origins.groupBy { it.content } - for ((content, origins) in groupByContent) { - if (content.isEmpty()) continue - appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> - if (groupByContent.keys.count { !it.isEmpty() } > 1) { - appendPlatformsAsText(platforms) - } - appendContent(content) - } - } + appendOriginsGroupByContent(node) } + println("GN: ${node.path}") SectionsBuilder(node).build() } } @@ -925,6 +927,8 @@ typealias PlatformsData = Map> fun memberPlatforms(node: DocumentationNode): PlatformsData { val members = when { node.kind == NodeKind.GroupNode -> node.origins + node.kind in NodeKind.classLike -> emptyList() + node.kind in NodeKind.memberLike -> emptyList() else -> node.members } @@ -974,4 +978,21 @@ fun samePlatforms(platformsPerNode: Collection): Boolean { val first = platformsPerNode.firstOrNull()?.keys ?: return true return platformsPerNode.all { it.keys == first } +} + +fun locationHref( + from: Location, + to: DocumentationNode, + generator: NodeLocationAwareGenerator, + pathOnly: Boolean = false +): String { + val topLevelPage = to.references(RefKind.TopLevelPage).singleOrNull()?.to + if (topLevelPage != null) { + val signature = to.detailOrNull(NodeKind.Signature) + return from.relativePathTo( + generator.location(topLevelPage), + (signature?.name ?: to.name).takeUnless { pathOnly } + ) + } + return from.relativePathTo(generator.location(to)) } \ No newline at end of file diff --git a/core/src/main/kotlin/Locations/Location.kt b/core/src/main/kotlin/Locations/Location.kt index 4448fb99..ccefa6e3 100644 --- a/core/src/main/kotlin/Locations/Location.kt +++ b/core/src/main/kotlin/Locations/Location.kt @@ -26,7 +26,7 @@ data class FileLocation(val file: File) : Location { } val ownerFolder = file.parentFile!! val relativePath = ownerFolder.toPath().relativize(other.file.toPath()).toString().replace(File.separatorChar, '/') - return if (anchor == null) relativePath else relativePath + "#" + anchor + return if (anchor == null) relativePath else relativePath + "#" + anchor.urlEncoded() } } @@ -40,8 +40,22 @@ fun relativePathToNode(qualifiedName: List, hasMembers: Boolean): String } } +fun nodeActualQualifier(node: DocumentationNode): List { + val topLevelPage = node.references(RefKind.TopLevelPage).singleOrNull()?.to + if (topLevelPage != null) { + return nodeActualQualifier(topLevelPage) + } + return node.owner?.let { nodeActualQualifier(it) }.orEmpty() + node +} + +fun relativePathToNode(node: DocumentationNode): String { + val qualifier = nodeActualQualifier(node) + return relativePathToNode( + qualifier.map { it.name }, + qualifier.last().members.any() + ) +} -fun relativePathToNode(node: DocumentationNode) = relativePathToNode(node.path.map { it.name }, node.members.any()) fun identifierToFilename(path: String): String { if (path.isEmpty()) return "--root--" -- cgit From a6ca887f1813777e7751f435b947095a20aafb58 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Thu, 18 Oct 2018 21:43:57 +0300 Subject: Remove debug logging --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 3 --- 1 file changed, 3 deletions(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 33d26a93..7b18fcb4 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -407,7 +407,6 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, for ((content, origins) in groupByContent) { if (content.isEmpty()) continue appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> - println("FOG_GN_MULTI(${groupByContent.count { !it.key.isEmpty() }}):" + item.path.joinToString(" > ")) if (groupByContent.count { !it.key.isEmpty() } > 1) { appendPlatformsAsText(platforms) } @@ -455,7 +454,6 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, for ((sign, nodes) in groupBySignature) { appendAsPlatformDependentBlock(effectivePlatformsForMembers(nodes)) { platforms -> - println("GNPM: ${platforms.toList().joinToString { "${it.first}->${it.second.map { it.path.joinToString(separator = ">") }}" }}") val first = nodes.first() first.detailOrNull(NodeKind.Signature)?.let { if (item.kind !in NodeKind.classLike || !isSingleNode) @@ -657,7 +655,6 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, appendOriginsGroupByContent(node) } - println("GN: ${node.path}") SectionsBuilder(node).build() } } -- cgit From 8a2e8f8ddc37a8c548a18714f2ad87fb511bcb82 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Thu, 18 Oct 2018 21:44:30 +0300 Subject: Add non-single documentation reporting --- core/src/main/kotlin/Formats/StructuredFormatService.kt | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 7b18fcb4..46c7f1af 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -404,6 +404,9 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, if (item.kind == NodeKind.GroupNode) { val groupByContent = item.origins.groupBy { it.content } + if (groupByContent.count { !it.key.isEmpty() } > 1) { + if (groupByContent.size > 1) println("[mult] Found ov diff: ${generator.location(item).path}") + } for ((content, origins) in groupByContent) { if (content.isEmpty()) continue appendAsPlatformDependentBlock(effectivePlatformsForMembers(origins)) { platforms -> @@ -617,7 +620,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder, .toList() .sortedByDescending { it.second.size } - + if (groupByContent.size > 1) println("[mult] Found diff: ${generator.location(node).path}") for ((content, platforms) in groupByContent) { appendAsPlatformDependentBlock(platforms) { if (groupByContent.size > 1) { -- cgit From a9c91cb7dc54c1554be5cf8de90516c929c0c1cb Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Fri, 19 Oct 2018 18:14:36 +0300 Subject: Hard-code min compiler version for samples --- core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'core/src/main/kotlin/Formats') diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt index 3b2b2897..86bc9df9 100644 --- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt +++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt @@ -195,7 +195,7 @@ open class KotlinWebsiteHtmlOutputBuilder( } override fun appendSampleBlockCode(language: String, imports: () -> Unit, body: () -> Unit) { - div(to, "sample") { + div(to, "sample", otherAttributes = " data-min-compiler-version=\"1.3\"") { appendBlockCode(language) { imports() wrap("\n\nfun main(args: Array) {".htmlEscape(), "}") { -- cgit