diff options
Diffstat (limited to 'plugins/base/src/main/kotlin/transformers')
5 files changed, 1 insertions, 743 deletions
diff --git a/plugins/base/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/plugins/base/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt deleted file mode 100644 index 1358cef1..00000000 --- a/plugins/base/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt +++ /dev/null @@ -1,338 +0,0 @@ -package org.jetbrains.dokka.base.transformers.descriptors - -import org.jetbrains.dokka.analysis.DokkaResolutionFacade -import org.jetbrains.dokka.links.Callable -import org.jetbrains.dokka.links.DRI -import org.jetbrains.dokka.links.withClass -import org.jetbrains.dokka.model.* -import org.jetbrains.dokka.model.ClassKind -import org.jetbrains.dokka.model.Enum -import org.jetbrains.dokka.model.Function -import org.jetbrains.dokka.model.Property -import org.jetbrains.dokka.model.doc.* -import org.jetbrains.dokka.pages.PlatformData -import org.jetbrains.dokka.parsers.MarkdownParser -import org.jetbrains.dokka.plugability.DokkaContext -import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTranslator -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies -import org.jetbrains.kotlin.idea.kdoc.findKDoc -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe -import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny -import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces -import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter -import org.jetbrains.kotlin.resolve.scopes.MemberScope -import org.jetbrains.kotlin.types.KotlinType -import kotlin.reflect.KClass - -class DefaultDescriptorToDocumentationTranslator( - private val context: DokkaContext -) : DescriptorToDocumentationTranslator { - override fun invoke( - moduleName: String, - packageFragments: Iterable<PackageFragmentDescriptor>, - platformData: PlatformData - ) = DokkaDescriptorVisitor(platformData, context.platforms[platformData]?.facade!!).run { - packageFragments.map { - visitPackageFragmentDescriptor( - it, - DRIWithPlatformInfo(DRI.topLevel, null, emptyList()) - ) - } - }.let { Module(moduleName, it) } - -} - - -data class DRIWithPlatformInfo( - val dri: DRI, - val expected: PlatformInfo?, - val actual: List<PlatformInfo> -) - -fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, null, emptyList()) - -open class DokkaDescriptorVisitor( // TODO: close this class and make it private together with DRIWithPlatformInfo - private val platformData: PlatformData, - private val resolutionFacade: DokkaResolutionFacade -) : DeclarationDescriptorVisitorEmptyBodies<Documentable, DRIWithPlatformInfo>() { - override fun visitDeclarationDescriptor(descriptor: DeclarationDescriptor, parent: DRIWithPlatformInfo): Nothing { - throw IllegalStateException("${javaClass.simpleName} should never enter ${descriptor.javaClass.simpleName}") - } - - override fun visitPackageFragmentDescriptor( - descriptor: PackageFragmentDescriptor, - parent: DRIWithPlatformInfo - ): Package { - val driWithPlatform = DRI(packageName = descriptor.fqName.asString()).withEmptyInfo() - val scope = descriptor.getMemberScope() - - return Package( - dri = driWithPlatform.dri, - functions = scope.functions(driWithPlatform), - properties = scope.properties(driWithPlatform), - classlikes = scope.classlikes(driWithPlatform) - ) - } - - override fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Classlike = - when (descriptor.kind) { - org.jetbrains.kotlin.descriptors.ClassKind.ENUM_CLASS -> enumDescriptor(descriptor, parent) - else -> classDescriptor(descriptor, parent) - } - - fun enumDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Enum { - val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo() - val scope = descriptor.unsubstitutedMemberScope - val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData() - - return Enum( - dri = driWithPlatform.dri, - name = descriptor.name.asString(), - entries = scope.classlikes(driWithPlatform).filter { it.kind == KotlinClassKindTypes.ENUM_ENTRY }.map { - EnumEntry( - it - ) - }, - constructors = descriptor.constructors.map { visitConstructorDescriptor(it, driWithPlatform) }, - functions = scope.functions(driWithPlatform), - properties = scope.properties(driWithPlatform), - classlikes = scope.classlikes(driWithPlatform), - expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData(), - actual = listOfNotNull(descriptorData), - extra = mutableSetOf(), // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet() - visibility = mapOf(platformData to descriptor.visibility) - ) - } - - fun classDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Class { - val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo() - val scope = descriptor.unsubstitutedMemberScope - val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData() - val expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData() - val actual = listOfNotNull(descriptorData) - return Class( - dri = driWithPlatform.dri, - name = descriptor.name.asString(), - kind = KotlinClassKindTypes.valueOf(descriptor.kind.toString()), - constructors = descriptor.constructors.map { - visitConstructorDescriptor( - it, - if (it.isPrimary) - DRIWithPlatformInfo( - driWithPlatform.dri, - expected?.info.filterTagWrappers(listOf(Constructor::class)), - actual.filterTagWrappers(listOf(Constructor::class)) - ) - else - DRIWithPlatformInfo(driWithPlatform.dri, null, emptyList()) - ) - }, - functions = scope.functions(driWithPlatform), - properties = scope.properties(driWithPlatform), - classlikes = scope.classlikes(driWithPlatform), - expected = expected, - actual = actual, - extra = mutableSetOf(), // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet() - visibility = mapOf(platformData to descriptor.visibility) - ) - } - - override fun visitPropertyDescriptor(descriptor: PropertyDescriptor, parent: DRIWithPlatformInfo): Property { - val expected = descriptor.takeIf { it.isExpect }?.resolveDescriptorData() - val actual = listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData()) - val dri = parent.dri.copy(callable = Callable.from(descriptor)) - - return Property( - dri = dri, - name = descriptor.name.asString(), - receiver = descriptor.extensionReceiverParameter?.let { - visitReceiverParameterDescriptor( - it, - DRIWithPlatformInfo( - dri, - expected?.filterTagWrappers(listOf(Receiver::class)), - actual.filterTagWrappers(listOf(Receiver::class)) - ) - ) - }, - expected = expected, - actual = actual, - accessors = descriptor.accessors.map { visitPropertyAccessorDescriptor(it, descriptor, dri) }, - visibility = mapOf(platformData to descriptor.visibility) - ) - } - - override fun visitFunctionDescriptor(descriptor: FunctionDescriptor, parent: DRIWithPlatformInfo): Function { - val expected = descriptor.takeIf { it.isExpect }?.resolveDescriptorData() - val actual = listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData()) - val dri = parent.dri.copy(callable = Callable.from(descriptor)) - - return Function( - dri = dri, - name = descriptor.name.asString(), - returnType = descriptor.returnType?.let { KotlinTypeWrapper(it) }, - isConstructor = false, - receiver = descriptor.extensionReceiverParameter?.let { - visitReceiverParameterDescriptor( - it, - DRIWithPlatformInfo( - dri, - expected?.filterTagWrappers(listOf(Receiver::class)), - actual.filterTagWrappers(listOf(Receiver::class)) - ) - ) - }, - parameters = descriptor.valueParameters.mapIndexed { index, desc -> - parameter( - index, desc, - DRIWithPlatformInfo( - dri, - expected.filterTagWrappers(listOf(Param::class), desc.name.asString()), - actual.filterTagWrappers(listOf(Param::class), desc.name.asString()) - ) - ) - }, - expected = expected, - actual = actual, - visibility = mapOf(platformData to descriptor.visibility) - ) - } - - override fun visitConstructorDescriptor(descriptor: ConstructorDescriptor, parent: DRIWithPlatformInfo): Function { - val dri = parent.dri.copy(callable = Callable.from(descriptor)) - return Function( - dri = dri, - name = "<init>", - returnType = KotlinTypeWrapper(descriptor.returnType), - isConstructor = true, - receiver = null, - parameters = descriptor.valueParameters.mapIndexed { index, desc -> - parameter( - index, desc, - DRIWithPlatformInfo( - dri, - parent.expected.filterTagWrappers(listOf(Param::class)), - parent.actual.filterTagWrappers(listOf(Param::class)) - ) - ) - }, - expected = parent.expected ?: descriptor.takeIf { it.isExpect }?.resolveDescriptorData(), - actual = parent.actual, - visibility = mapOf(platformData to descriptor.visibility) - ) - } - - override fun visitReceiverParameterDescriptor( - descriptor: ReceiverParameterDescriptor, - parent: DRIWithPlatformInfo - ) = Parameter( - dri = parent.dri.copy(target = 0), - name = null, - type = KotlinTypeWrapper(descriptor.type), - expected = parent.expected, - actual = parent.actual - ) - - open fun visitPropertyAccessorDescriptor( - descriptor: PropertyAccessorDescriptor, - propertyDescriptor: PropertyDescriptor, - parent: DRI - ): Function { - val dri = parent.copy(callable = Callable.from(descriptor)) - val isGetter = descriptor is PropertyGetterDescriptor - - fun PropertyDescriptor.asParameter(parent: DRI) = - Parameter( - parent.copy(target = 1), - this.name.asString(), - KotlinTypeWrapper(this.type), - descriptor.takeIf { it.isExpect }?.resolveDescriptorData(), - listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData()) - ) - - val name = run { - val modifier = if (isGetter) "get" else "set" - val rawName = propertyDescriptor.name.asString() - "$modifier${rawName[0].toUpperCase()}${rawName.drop(1)}" - } - - descriptor.visibility - val parameters = - if (isGetter) { - emptyList() - } else { - listOf(propertyDescriptor.asParameter(dri)) - } - - return Function( - dri, - name, - descriptor.returnType?.let { KotlinTypeWrapper(it) }, - false, - null, - parameters, - descriptor.takeIf { it.isExpect }?.resolveDescriptorData(), - listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData()), - visibility = mapOf(platformData to descriptor.visibility) - ) - } - - private fun parameter(index: Int, descriptor: ValueParameterDescriptor, parent: DRIWithPlatformInfo) = - Parameter( - dri = parent.dri.copy(target = index + 1), - name = descriptor.name.asString(), - type = KotlinTypeWrapper(descriptor.type), - expected = parent.expected, - actual = parent.actual - ) - - private fun MemberScope.functions(parent: DRIWithPlatformInfo): List<Function> = - getContributedDescriptors(DescriptorKindFilter.FUNCTIONS) { true } - .filterIsInstance<FunctionDescriptor>() - .map { visitFunctionDescriptor(it, parent) } - - private fun MemberScope.properties(parent: DRIWithPlatformInfo): List<Property> = - getContributedDescriptors(DescriptorKindFilter.VALUES) { true } - .filterIsInstance<PropertyDescriptor>() - .map { visitPropertyDescriptor(it, parent) } - - private fun MemberScope.classlikes(parent: DRIWithPlatformInfo): List<Classlike> = - getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) { true } - .filterIsInstance<ClassDescriptor>() - .map { visitClassDescriptor(it, parent) } - - private fun DeclarationDescriptor.resolveDescriptorData(): PlatformInfo { - val doc = findKDoc() - val parser = MarkdownParser(resolutionFacade, this) - val docHeader = parser.parseFromKDocTag(doc) - - return BasePlatformInfo(docHeader, listOf(platformData)) - } - - private fun ClassDescriptor.resolveClassDescriptionData(): ClassPlatformInfo { - return ClassPlatformInfo(resolveDescriptorData(), - (getSuperInterfaces() + getAllSuperclassesWithoutAny()).map { DRI.from(it) }) - } - - private fun PlatformInfo?.filterTagWrappers( - types: List<KClass<out TagWrapper>>, - name: String? = null - ): PlatformInfo? { - if (this == null) - return null - return BasePlatformInfo( - DocumentationNode( - this.documentationNode.children.filter { it::class in types && (it as? NamedTagWrapper)?.name == name } - ), - this.platformData - ) - } - - private fun List<PlatformInfo>.filterTagWrappers( - types: List<KClass<out TagWrapper>>, - name: String? = null - ): List<PlatformInfo> = - this.map { it.filterTagWrappers(types, name)!! } -} - diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt deleted file mode 100644 index d28791ab..00000000 --- a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt +++ /dev/null @@ -1,27 +0,0 @@ -package org.jetbrains.dokka.base.transformers.documentables - -import org.jetbrains.dokka.CoreExtensions -import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter -import org.jetbrains.dokka.model.Module -import org.jetbrains.dokka.pages.ModulePageNode -import org.jetbrains.dokka.plugability.DokkaContext -import org.jetbrains.dokka.transformers.documentation.DocumentablesToPageTranslator -import org.jetbrains.dokka.utilities.DokkaLogger - - -class DefaultDocumentablesToPageTranslator( - private val commentsToContentConverter: CommentsToContentConverter, - private val logger: DokkaLogger -) : DocumentablesToPageTranslator { - override fun invoke(module: Module): ModulePageNode = - DefaultPageBuilder { node, kind, operation -> - DefaultPageContentBuilder.group( - setOf(node.dri), - node.platformData, - kind, - commentsToContentConverter, - logger, - operation - ) - }.pageForModule(module) -}
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/PageBuilder.kt b/plugins/base/src/main/kotlin/transformers/documentables/PageBuilder.kt deleted file mode 100644 index 29f39c73..00000000 --- a/plugins/base/src/main/kotlin/transformers/documentables/PageBuilder.kt +++ /dev/null @@ -1,159 +0,0 @@ -package org.jetbrains.dokka.base.transformers.documentables - -import org.jetbrains.dokka.model.* -import org.jetbrains.dokka.model.Enum -import org.jetbrains.dokka.model.Function -import org.jetbrains.dokka.model.doc.TagWrapper -import org.jetbrains.dokka.pages.* - -open class DefaultPageBuilder( - override val rootContentGroup: RootContentBuilder -) : PageBuilder { - - override fun pageForModule(m: Module): ModulePageNode = - ModulePageNode(m.name.ifEmpty { "root" }, contentForModule(m), m, m.packages.map { pageForPackage(it) }) - - override fun pageForPackage(p: Package) = - PackagePageNode(p.name, contentForPackage(p), setOf(p.dri), p, - p.classlikes.map { pageForClasslike(it) } + - p.functions.map { pageForMember(it) }) - - override fun pageForClasslike(c: Classlike): ClasslikePageNode { - val constructors = when (c) { - is Class -> c.constructors - is Enum -> c.constructors - else -> emptyList() - } - - return ClasslikePageNode(c.name, contentForClasslike(c), setOf(c.dri), c, - constructors.map { pageForMember(it) } + - c.classlikes.map { pageForClasslike(it) } + - c.functions.map { pageForMember(it) }) - } - - override fun pageForMember(m: CallableNode): MemberPageNode = - when (m) { - is Function -> - MemberPageNode(m.name, contentForFunction(m), setOf(m.dri), m) - else -> throw IllegalStateException("$m should not be present here") - } - - protected open fun group(node: Documentable, content: PageContentBuilderFunction) = - rootContentGroup(node, ContentKind.Main, content) - - protected open fun contentForModule(m: Module) = group(m) { - header(1) { text("root") } - block("Packages", 2, ContentKind.Packages, m.packages, m.platformData) { - link(it.name, it.dri) - } - text("Index\n") - text("Link to allpage here") - } - - protected open fun contentForPackage(p: Package) = group(p) { - header(1) { text("Package ${p.name}") } - block("Types", 2, ContentKind.Properties, p.classlikes, p.platformData) { - link(it.name, it.dri) - text(it.briefDocTagString) - } - block("Functions", 2, ContentKind.Functions, p.functions, p.platformData) { - link(it.name, it.dri) - signature(it) - text(it.briefDocTagString) - } - } - - open fun contentForClasslike(c: Classlike): ContentGroup = when (c) { - is Class -> contentForClass(c) - is Enum -> contentForEnum(c) - else -> throw IllegalStateException("$c should not be present here") - } - - protected fun contentForClass(c: Class) = group(c) { - header(1) { text(c.name) } - - c.inherited.takeIf { it.isNotEmpty() }?.let { - header(2) { text("SuperInterfaces") } - linkTable(it) - } - contentForComments(c) - block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) { - link(it.name, it.dri) - signature(it) - text(it.briefDocTagString) - } - block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) { - link(it.name, it.dri) - signature(it) - text(it.briefDocTagString) - } - block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) { - link(it.name, it.dri) - text(it.briefDocTagString) - - } - } - - fun contentForEnum(c: Enum): ContentGroup = group(c) { - header(1) { text("enum ${c.name}") } - - block("Entries", 2, ContentKind.Properties, c.entries, c.platformData) { entry -> - link(entry.name, entry.dri) - contentForComments(entry) - } - - c.inherited.takeIf { it.isNotEmpty() }?.let { - header(2) { text("SuperInterfaces") } - linkTable(it) - } - contentForComments(c) - block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) { - link(it.name, it.dri) - signature(it) - text(it.briefDocTagString) - } - block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) { - link(it.name, it.dri) - signature(it) - text(it.briefDocTagString) - } - block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) { - link(it.name, it.dri) - text(it.briefDocTagString) - } - } - - private fun PageContentBuilder.contentForComments(d: Documentable) = - d.platformInfo.forEach { platformInfo -> - platformInfo.documentationNode.children.forEach { - header(3) { - text(it.toHeaderString()) - text(" [${platformInfo.platformData.joinToString(", ") { it.platformType.name }}]") - } - comment(it.root) - text("\n") - } - } - - private fun contentForFunction(f: Function) = group(f) { - header(1) { text(f.name) } - signature(f) - contentForComments(f) - block("Parameters", 2, ContentKind.Parameters, f.children, f.platformData) { - text(it.name ?: "<receiver>") - it.platformInfo.forEach { it.documentationNode.children.forEach { comment(it.root) } } - } - } - - private fun TagWrapper.toHeaderString() = this.javaClass.toGenericString().split('.').last() -} - -typealias RootContentBuilder = (Documentable, Kind, PageContentBuilderFunction) -> ContentGroup - -interface PageBuilder { - val rootContentGroup: RootContentBuilder - fun pageForModule(m: Module): ModulePageNode - fun pageForPackage(p: Package): PackagePageNode - fun pageForMember(m: CallableNode): MemberPageNode - fun pageForClasslike(c: Classlike): ClasslikePageNode -}
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt deleted file mode 100644 index 6ce883b1..00000000 --- a/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt +++ /dev/null @@ -1,218 +0,0 @@ -package org.jetbrains.dokka.base.transformers.documentables - -import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter -import org.jetbrains.dokka.links.DRI -import org.jetbrains.dokka.model.Documentable -import org.jetbrains.dokka.model.Function -import org.jetbrains.dokka.model.TypeWrapper -import org.jetbrains.dokka.model.doc.DocTag -import org.jetbrains.dokka.pages.* -import org.jetbrains.dokka.utilities.DokkaLogger - -open class DefaultPageContentBuilder( - protected val dri: Set<DRI>, - protected val platformData: Set<PlatformData>, - protected val kind: Kind, - protected val commentsConverter: CommentsToContentConverter, - val logger: DokkaLogger, - protected val styles: Set<Style> = emptySet(), - protected val extras: Set<Extra> = emptySet() -) : PageContentBuilder { - protected val contents = mutableListOf<ContentNode>() - - protected fun createText(text: String, kind: Kind = ContentKind.Symbol) = - ContentText(text, DCI(dri, kind), platformData, styles, extras) - - protected fun build() = ContentGroup( - contents.toList(), - DCI(dri, kind), - platformData, - styles, - extras - ) - - override fun header(level: Int, block: PageContentBuilderFunction) { - contents += ContentHeader(level, group(ContentKind.Symbol, block)) - } - - override fun text(text: String, kind: Kind) { - contents += createText(text, kind) - } - - protected fun signature(f: Function, block: PageContentBuilderFunction) { - contents += group(setOf(f.dri), f.platformData, ContentKind.Symbol, block) - } - - override fun signature(f: Function) = signature(f) { - text("fun ") - f.receiver?.also { - type(it.type) - text(".") - } - link(f.name, f.dri) - text("(") - list(f.parameters) { - link(it.name!!, it.dri) - text(": ") - type(it.type) - } - text(")") - val returnType = f.returnType - if (!f.isConstructor && returnType != null && - returnType.constructorFqName != Unit::class.qualifiedName - ) { - text(": ") - type(returnType) - } - } - - override fun linkTable(elements: List<DRI>) { - contents += ContentTable( - emptyList(), - elements.map { group(dri, platformData, ContentKind.Classes) { link(it.classNames ?: "", it) } }, - DCI(dri, kind), - platformData, styles, extras - ) - } - - override fun <T : Documentable> block( - name: String, - level: Int, - kind: Kind, - elements: Iterable<T>, - platformData: Set<PlatformData>, - operation: PageContentBuilder.(T) -> Unit - ) { - header(level) { text(name) } - - contents += ContentTable( - emptyList(), - elements.map { group(setOf(it.dri), it.platformData, kind) { operation(it) } }, - DCI(dri, kind), - platformData, styles, extras - ) - } - - override fun <T> list( - elements: List<T>, - prefix: String, - suffix: String, - separator: String, - operation: PageContentBuilder.(T) -> Unit - ) { - if (elements.isNotEmpty()) { - if (prefix.isNotEmpty()) text(prefix) - elements.dropLast(1).forEach { - operation(it) - text(separator) - } - operation(elements.last()) - if (suffix.isNotEmpty()) text(suffix) - } - } - - override fun link(text: String, address: DRI, kind: Kind) { - contents += ContentDRILink( - listOf(createText(text)), - address, - DCI(dri, kind), - platformData - ) - } - - override fun link(address: DRI, kind: Kind, block: PageContentBuilderFunction) { - contents += ContentDRILink( - group(ContentKind.Main, block).children, - address, - DCI(dri, kind), - platformData - ) - } - - override fun comment(docTag: DocTag) { - contents += group(ContentKind.Comment) { - with(this as DefaultPageContentBuilder) { - contents += commentsConverter.buildContent( - docTag, - DCI(dri, ContentKind.Comment), - platformData - ) - } - } - } - - fun group(kind: Kind, block: PageContentBuilderFunction): ContentGroup = - group(dri, platformData, kind, block) - - override fun group( - dri: Set<DRI>, - platformData: Set<PlatformData>, - kind: Kind, - block: PageContentBuilderFunction - ): ContentGroup = group(dri, platformData, kind, commentsConverter, logger, block) - - companion object { - fun group( - dri: Set<DRI>, - platformData: Set<PlatformData>, - kind: Kind, - commentsConverter: CommentsToContentConverter, - logger: DokkaLogger, - block: PageContentBuilderFunction - ): ContentGroup = - DefaultPageContentBuilder(dri, platformData, kind, commentsConverter, logger).apply(block).build() - } -} - - -fun PageContentBuilder.type(t: TypeWrapper) { - if (t.constructorNamePathSegments.isNotEmpty() && t.dri != null) - link(t.constructorNamePathSegments.last(), t.dri!!) - else if (t.constructorNamePathSegments.isNotEmpty() && t.dri == null) - text(t.toString()) - else (this as? DefaultPageContentBuilder)?.let { - logger.error("type $t cannot be resolved") - text("???") - } - list(t.arguments, prefix = "<", suffix = ">") { - type(it) - } -} - -typealias PageContentBuilderFunction = PageContentBuilder.() -> Unit - -@DslMarker -annotation class ContentMarker - -@ContentMarker -interface PageContentBuilder { - fun group( - dri: Set<DRI>, - platformData: Set<PlatformData>, - kind: Kind, block: PageContentBuilderFunction - ): ContentGroup - - fun text(text: String, kind: Kind = ContentKind.Symbol) - fun signature(f: Function) - fun link(text: String, address: DRI, kind: Kind = ContentKind.Symbol) - fun link(address: DRI, kind: Kind = ContentKind.Symbol, block: PageContentBuilderFunction) - fun linkTable(elements: List<DRI>) - fun comment(docTag: DocTag) - fun header(level: Int, block: PageContentBuilderFunction) - fun <T> list( - elements: List<T>, - prefix: String = "", - suffix: String = "", - separator: String = ",", - operation: PageContentBuilder.(T) -> Unit - ) - - fun <T : Documentable> block( - name: String, - level: Int, - kind: Kind, - elements: Iterable<T>, - platformData: Set<PlatformData>, - operation: PageContentBuilder.(T) -> Unit - ) -}
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/pages/merger/PageNodeMerger.kt b/plugins/base/src/main/kotlin/transformers/pages/merger/PageNodeMerger.kt index 5ecf8d9b..96cd126c 100644 --- a/plugins/base/src/main/kotlin/transformers/pages/merger/PageNodeMerger.kt +++ b/plugins/base/src/main/kotlin/transformers/pages/merger/PageNodeMerger.kt @@ -25,5 +25,5 @@ private fun <T> Iterable<T>.assertSingle(path: List<String>): T = try { single() } catch (e: Exception) { val renderedPath = path.joinToString(separator = "/") - throw IllegalStateException("Page merger is missconfigured. Error for $renderedPath: ${e.message}") + throw IllegalStateException("Page merger is misconfigured. Error for $renderedPath: ${e.message}") }
\ No newline at end of file |