Kotlin · MarcinAman · Jul 9, 2021 · Jul 7, 2021
diff --git a/plugins/base/api/base.api b/plugins/base/api/base.api
@@ -429,6 +429,11 @@ public class org/jetbrains/dokka/base/renderers/html/NavigationSearchInstaller :
 	public fun invoke (Lorg/jetbrains/dokka/pages/RootPageNode;)Lorg/jetbrains/dokka/pages/RootPageNode;
 }
 
+public class org/jetbrains/dokka/base/renderers/html/STRIKE : kotlinx/html/HTMLTag, kotlinx/html/HtmlBlockInlineTag {
+	public fun <init> (Ljava/util/Map;Lkotlinx/html/TagConsumer;)V
+	public fun getConsumer ()Lkotlinx/html/TagConsumer;
+}
+
 public final class org/jetbrains/dokka/base/renderers/html/ScriptsInstaller : org/jetbrains/dokka/transformers/pages/PageTransformer {
 	public fun <init> (Lorg/jetbrains/dokka/plugability/DokkaContext;)V
 	public fun invoke (Lorg/jetbrains/dokka/pages/RootPageNode;)Lorg/jetbrains/dokka/pages/RootPageNode;
@@ -493,6 +498,8 @@ public final class org/jetbrains/dokka/base/renderers/html/StylesInstaller : org
 
 public final class org/jetbrains/dokka/base/renderers/html/TagsKt {
 	public static final fun buildAsInnerHtml (Lkotlin/jvm/functions/Function1;)Ljava/lang/String;
+	public static final fun strike (Lkotlinx/html/FlowOrPhrasingContent;Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V
+	public static synthetic fun strike$default (Lkotlinx/html/FlowOrPhrasingContent;Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
 	public static final fun templateCommand (Lkotlinx/html/FlowOrMetaDataContent;Lorg/jetbrains/dokka/base/templating/Command;Lkotlin/jvm/functions/Function1;)V
 	public static final fun templateCommand (Lkotlinx/html/TagConsumer;Lorg/jetbrains/dokka/base/templating/Command;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 	public static synthetic fun templateCommand$default (Lkotlinx/html/FlowOrMetaDataContent;Lorg/jetbrains/dokka/base/templating/Command;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V

diff --git a/plugins/base/base-test-utils/api/base-test-utils.api b/plugins/base/base-test-utils/api/base-test-utils.api
@@ -100,10 +100,18 @@ public final class utils/AssertHtmlEqualsIgnoringWhitespaceKt {
 	public static final fun assertHtmlEqualsIgnoringWhitespace (Ljava/lang/String;Ljava/lang/String;)V
 }
 
+public final class utils/B : utils/Tag {
+	public fun <init> ([Ljava/lang/Object;)V
+}
+
 public final class utils/Div : utils/Tag {
 	public fun <init> ([Ljava/lang/Object;)V
 }
 
+public final class utils/I : utils/Tag {
+	public fun <init> ([Ljava/lang/Object;)V
+}
+
 public final class utils/JsoupUtilsKt {
 	public static final fun match (Lorg/jsoup/nodes/Element;[Ljava/lang/Object;)V
 }
@@ -112,6 +120,10 @@ public final class utils/P : utils/Tag {
 	public fun <init> ([Ljava/lang/Object;)V
 }
 
+public final class utils/STRIKE : utils/Tag {
+	public fun <init> ([Ljava/lang/Object;)V
+}
+
 public final class utils/Span : utils/Tag {
 	public fun <init> ([Ljava/lang/Object;)V
 }

diff --git a/plugins/base/base-test-utils/src/main/kotlin/renderers/JsoupUtils.kt b/plugins/base/base-test-utils/src/main/kotlin/renderers/JsoupUtils.kt
@@ -16,6 +16,9 @@ class Div(vararg matchers: Any) : Tag("div", *matchers)
 class P(vararg matchers: Any) : Tag("p", *matchers)
 class Span(vararg matchers: Any) : Tag("span", *matchers)
 class A(vararg matchers: Any) : Tag("a", *matchers)
+class B(vararg matchers: Any) : Tag("b", *matchers)
+class I(vararg matchers: Any) : Tag("i", *matchers)
+class STRIKE(vararg matchers: Any) : Tag("strike", *matchers)
 object Wbr : Tag("wbr")
 private fun Any.accepts(n: Node) {
     when (this) {

diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -703,18 +703,37 @@ open class HtmlRenderer(
         }
     }
 
-    override fun FlowContent.buildText(textNode: ContentText) =
+    override fun FlowContent.buildText(textNode: ContentText) = buildText(textNode, textNode.style)
+
+    private fun FlowContent.buildText(textNode: ContentText, unappliedStyles: Set<Style>) {
         when {
             textNode.extra[HtmlContent] != null -> {
                 consumer.onTagContentUnsafe { raw(textNode.text) }
             }
-            textNode.hasStyle(TextStyle.Indented) -> {
+            unappliedStyles.contains(TextStyle.Indented) -> {
                 consumer.onTagContentEntity(Entities.nbsp)
-                text(textNode.text)
+                buildText(textNode, unappliedStyles - TextStyle.Indented)
+            }
+            unappliedStyles.size == 1 && unappliedStyles.contains(TextStyle.Cover) -> buildBreakableText(textNode.text)
+            unappliedStyles.isNotEmpty() -> {
+                val styleToApply = unappliedStyles.first()
+                applyStyle(styleToApply){
+                    buildText(textNode, unappliedStyles - styleToApply)
+                }
             }
-            textNode.hasStyle(TextStyle.Cover) -> buildBreakableText(textNode.text)
             else -> text(textNode.text)
         }
+    }
+
+    private inline fun FlowContent.applyStyle(styleToApply: Style, crossinline body: FlowContent.() -> Unit){
+        when(styleToApply){
+            TextStyle.Bold -> b { body() }
+            TextStyle.Italic -> i { body() }
+            TextStyle.Strikethrough -> strike { body() }
+            TextStyle.Strong -> strong { body() }
+            else -> body()
+        }
+    }
 
     override fun render(root: RootPageNode) {
         shouldRenderSourceSetBubbles = shouldRenderSourceSetBubbles(root)

diff --git a/plugins/base/src/main/kotlin/renderers/html/Tags.kt b/plugins/base/src/main/kotlin/renderers/html/Tags.kt
@@ -17,6 +17,16 @@ open class WBR(initialAttributes: Map<String, String>, consumer: TagConsumer<*>)
     HTMLTag("wbr", consumer, initialAttributes, namespace = null, inlineTag = true, emptyTag = false),
     HtmlBlockInlineTag
 
+/**
+ * Work-around until next version of kotlinx.html doesn't come out
+ */
+@HtmlTagMarker
+inline fun FlowOrPhrasingContent.strike(classes : String? = null, crossinline block : STRIKE.() -> Unit = {}) : Unit = STRIKE(attributesMapOf("class", classes), consumer).visit(block)
+
+open class STRIKE(initialAttributes : Map<String, String>, override val consumer : TagConsumer<*>) : HTMLTag("strike", consumer, initialAttributes, null, false, false), HtmlBlockInlineTag {
+
+}
+
 fun FlowOrMetaDataContent.templateCommand(data: Command, block: TemplateBlock = {}): Unit =
     (consumer as? ImmediateResolutionTagConsumer)?.processCommand(data, block)
         ?: TemplateCommand(attributesMapOf("data", toJsonString(data)), consumer).visit(block)

diff --git a/plugins/base/src/test/kotlin/renderers/html/TextStylesTest.kt b/plugins/base/src/test/kotlin/renderers/html/TextStylesTest.kt
@@ -0,0 +1,65 @@
+package renderers.html
+
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.pages.TextStyle
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+import org.junit.jupiter.api.Test
+import renderers.testPage
+import utils.B
+import utils.I
+import utils.STRIKE
+import utils.match
+
+class TextStylesTest : HtmlRenderingOnlyTestBase() {
+    @Test
+    fun `should include bold`(){
+        val page = testPage {
+            text("bold text", styles = setOf(TextStyle.Bold))
+        }
+        HtmlRenderer(context).render(page)
+        renderedContent.match(B("bold text"))
+    }
+
+    @Test
+    fun `should include italics`(){
+        val page = testPage {
+            text("italics text", styles = setOf(TextStyle.Italic))
+        }
+        HtmlRenderer(context).render(page)
+        renderedContent.match(I("italics text"))
+    }
+
+    @Test
+    fun `should include strikethrought`(){
+        val page = testPage {
+            text("strike text", styles = setOf(TextStyle.Strikethrough))
+        }
+        HtmlRenderer(context).render(page)
+        renderedContent.match(STRIKE("strike text"))
+    }
+
+    @Test
+    fun `should include multiple styles at one`(){
+        val page = testPage {
+            text(
+                "styled text",
+                styles = setOf(
+                    TextStyle.Strikethrough,
+                    TextStyle.Bold,
+                    TextStyle.Indented,
+                    TextStyle.UnderCoverText,
+                    TextStyle.BreakableAfter
+                )
+            )
+        }
+        HtmlRenderer(context).render(page)
+        renderedContent.match(STRIKE(B("styled text")))
+        //Our dsl swallows nbsp so i manually check for it
+        files.contents.getValue("test-page.html").contains("&nbsp;<strike><b>styled text</b></strike>")
+    }
+
+
+    override val renderedContent: Element
+        get() = files.contents.getValue("test-page.html").let { Jsoup.parse(it) }.select("#content").single()
+}