Replacing assertPrints, assertTrue to println for kotlin-website samples, Added SampleProcessingService to FormatDescriptor

3 files changed, 195 insertions, 0 deletions

diff --git a/core/src/main/kotlin/Samples/DefaultSampleProcessingService.kt b/core/src/main/kotlin/Samples/DefaultSampleProcessingService.kt
new file mode 100644
index 00000000..26841ea6
--- /dev/null
+++ b/core/src/main/kotlin/Samples/DefaultSampleProcessingService.kt
@@ -0,0 +1,106 @@
+package Samples
+
+import com.google.inject.Inject
+import com.intellij.psi.PsiElement
+import org.jetbrains.dokka.*
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
+import org.jetbrains.kotlin.idea.kdoc.getKDocLinkResolutionScope
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.ResolutionScope
+
+
+open class DefaultSampleProcessingService
+@Inject constructor(val options: DocumentationOptions,
+                    val logger: DokkaLogger,
+                    val resolutionFacade: DokkaResolutionFacade)
+    : SampleProcessingService {
+
+    override fun resolveSample(descriptor: DeclarationDescriptor, functionName: String?): ContentNode {
+        if (functionName == null) {
+            logger.warn("Missing function name in @sample in ${descriptor.signature()}")
+            return ContentBlockSampleCode().apply { append(ContentText("//Missing function name in @sample")) }
+        }
+        val scope = getKDocLinkResolutionScope(resolutionFacade, descriptor)
+        val rootPackage = resolutionFacade.moduleDescriptor.getPackage(FqName.ROOT)
+        val rootScope = rootPackage.memberScope
+        val symbol = resolveInScope(functionName, scope) ?: resolveInScope(functionName, rootScope)
+        if (symbol == null) {
+            logger.warn("Unresolved function $functionName in @sample in ${descriptor.signature()}")
+            return ContentBlockSampleCode().apply { append(ContentText("//Unresolved: $functionName")) }
+        }
+        val psiElement = DescriptorToSourceUtils.descriptorToDeclaration(symbol)
+        if (psiElement == null) {
+            logger.warn("Can't find source for function $functionName in @sample in ${descriptor.signature()}")
+            return ContentBlockSampleCode().apply { append(ContentText("//Source not found: $functionName")) }
+        }
+
+        val text = processSampleBody(psiElement)
+
+        val lines = text.trimEnd().split("\n".toRegex()).toTypedArray().filterNot(String::isEmpty)
+        val indent = lines.map { it.takeWhile(Char::isWhitespace).count() }.min() ?: 0
+        val finalText = lines.map { it.drop(indent) }.joinToString("\n")
+
+        return ContentBlockSampleCode(importsBlock = processImports(psiElement)).apply { append(ContentText(finalText)) }
+    }
+
+    protected open fun processSampleBody(psiElement: PsiElement): String = when (psiElement) {
+        is KtDeclarationWithBody -> {
+            val bodyExpression = psiElement.bodyExpression
+            when (bodyExpression) {
+                is KtBlockExpression -> bodyExpression.text.removeSurrounding("{", "}")
+                else -> bodyExpression!!.text
+            }
+        }
+        else -> psiElement.text
+    }
+
+    protected open fun processImports(psiElement: PsiElement): ContentBlockCode {
+        val psiFile = psiElement.containingFile
+        if (psiFile is KtFile) {
+            return ContentBlockCode("kotlin").apply {
+                append(ContentText(psiFile.importList?.text ?: ""))
+            }
+        } else {
+            return ContentBlockCode("")
+        }
+    }
+
+    private fun resolveInScope(functionName: String, scope: ResolutionScope): DeclarationDescriptor? {
+        var currentScope = scope
+        val parts = functionName.split('.')
+
+        var symbol: DeclarationDescriptor? = null
+
+        for (part in parts) {
+            // short name
+            val symbolName = Name.identifier(part)
+            val partSymbol = currentScope.getContributedDescriptors(DescriptorKindFilter.ALL, { it == symbolName })
+                    .filter { it.name == symbolName }
+                    .firstOrNull()
+
+            if (partSymbol == null) {
+                symbol = null
+                break
+            }
+            @Suppress("IfThenToElvis")
+            currentScope = if (partSymbol is ClassDescriptor)
+                partSymbol.defaultType.memberScope
+            else if (partSymbol is PackageViewDescriptor)
+                partSymbol.memberScope
+            else
+                getKDocLinkResolutionScope(resolutionFacade, partSymbol)
+            symbol = partSymbol
+        }
+
+        return symbol
+    }
+}
+
diff --git a/core/src/main/kotlin/Samples/KotlinWebsiteSampleProcessingService.kt b/core/src/main/kotlin/Samples/KotlinWebsiteSampleProcessingService.kt
new file mode 100644
index 00000000..864734ea
--- /dev/null
+++ b/core/src/main/kotlin/Samples/KotlinWebsiteSampleProcessingService.kt
@@ -0,0 +1,81 @@
+package Samples
+
+import com.google.inject.Inject
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.PsiElement
+import org.jetbrains.dokka.DocumentationOptions
+import org.jetbrains.dokka.DokkaLogger
+import org.jetbrains.dokka.DokkaResolutionFacade
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.startOffset
+import java.util.*
+
+open class KotlinWebsiteSampleProcessingService
+@Inject constructor(options: DocumentationOptions,
+                    logger: DokkaLogger,
+                    resolutionFacade: DokkaResolutionFacade)
+    : DefaultSampleProcessingService(options, logger, resolutionFacade) {
+
+
+    fun buildReplacementData(psiElement: PsiElement): Map<TextRange, String> {
+
+        val result = TreeMap<TextRange, String>({ o1, o2 -> o1.startOffset.compareTo(o2.startOffset) })
+        fun convertAssertPrints(expression: KtCallExpression) {
+            val (argument, commentArgument) = expression.valueArguments
+            val comment = commentArgument.getArgumentExpression() as KtStringTemplateExpression
+            val commentText = comment.entries.joinToString("") { it.text }
+            result[expression.textRange] = "println(${argument.text}) //$commentText"
+        }
+
+        fun convertAssertTrue(expression: KtCallExpression) {
+            val (argument) = expression.valueArguments
+            result[expression.textRange] = "println(\"${argument.text} is \${${argument.text}}\") //true "
+        }
+
+        if (psiElement is KtElement) {
+            val visitor = object : KtTreeVisitor<Any>() {
+                override fun visitCallExpression(expression: KtCallExpression, data: Any?): Void? {
+                    when (expression.calleeExpression?.text) {
+                        "assertPrints" -> convertAssertPrints(expression)
+                        "assertTrue" -> convertAssertTrue(expression)
+                        else -> super.visitCallExpression(expression, data)
+                    }
+                    return null
+                }
+            }
+            psiElement.acceptChildren(visitor)
+        }
+        return result
+    }
+
+    private fun String.applyReplacements(baseOffset: Int, replacementData: Map<TextRange, String>): String {
+        val partsList = arrayListOf<String>()
+        var prevRange = TextRange(0, baseOffset)
+        for ((range, replacement) in replacementData) {
+            partsList.add(substring(prevRange.endOffset - baseOffset, range.startOffset - baseOffset))
+            partsList.add(replacement)
+            prevRange = range
+        }
+        partsList.add(substring(prevRange.endOffset - baseOffset))
+        return partsList.joinToString(separator = "")
+    }
+
+
+    override fun processSampleBody(psiElement: PsiElement): String {
+
+        val replacementData = buildReplacementData(psiElement)
+
+        return when (psiElement) {
+            is KtDeclarationWithBody -> {
+                val bodyExpression = psiElement.bodyExpression
+                val bodyExpressionText = bodyExpression!!.text.applyReplacements(bodyExpression.startOffset, replacementData)
+                when (bodyExpression) {
+                    is KtBlockExpression -> bodyExpressionText.removeSurrounding("{", "}")
+                    else -> bodyExpressionText
+                }
+            }
+            else -> psiElement.text.applyReplacements(psiElement.startOffset, replacementData)
+        }
+    }
+}
+
diff --git a/core/src/main/kotlin/Samples/SampleProcessingService.kt b/core/src/main/kotlin/Samples/SampleProcessingService.kt
new file mode 100644
index 00000000..61abda6d
--- /dev/null
+++ b/core/src/main/kotlin/Samples/SampleProcessingService.kt
@@ -0,0 +1,8 @@
+package Samples
+
+import org.jetbrains.dokka.ContentNode
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+
+interface SampleProcessingService {
+    fun resolveSample(descriptor: DeclarationDescriptor, functionName: String?): ContentNode
+}
\ No newline at end of file