Add basic html generator

3 files changed, 206 insertions, 0 deletions

diff --git a/src/main/kotlin/moe/nea/blog/gen/HtmlGenerator.kt b/src/main/kotlin/moe/nea/blog/gen/HtmlGenerator.kt
new file mode 100644
index 0000000..ef0858a
--- /dev/null
+++ b/src/main/kotlin/moe/nea/blog/gen/HtmlGenerator.kt
@@ -0,0 +1,149 @@
+package moe.nea.blog.gen
+
+import moe.nea.blog.md.*
+import kotlin.reflect.KClass
+
+fun interface HtmlFragmentGenerator<T : MarkdownElement> {
+    fun generateHtml(htmlGenerator: HtmlGenerator, node: T): HtmlFragment
+}
+
+
+class HtmlFragment private constructor(val text: String) {
+    companion object {
+        fun ofUnescaped(text: String) = HtmlFragment(
+            text.replace("&", "&amp;")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+                .replace("\"", "&quot;")
+                .replace("'", "&#39;")
+        )
+
+        fun ofPreEscaped(text: String) = HtmlFragment(text)
+        fun empty(): HtmlFragment {
+            return HtmlFragment("")
+        }
+    }
+}
+
+annotation class HtmlDslMarker
+
+@HtmlDslMarker
+class HtmlDsl {
+    val parts = mutableListOf<HtmlFragment>()
+
+    fun append(string: String) {
+        parts.add(HtmlFragment.ofUnescaped(string))
+    }
+
+    fun append(fragment: HtmlFragment) {
+        parts.add(fragment)
+    }
+
+    fun appendPreEscaped(markup: String) {
+        append(HtmlFragment.ofPreEscaped(markup))
+    }
+
+    operator fun String.unaryPlus() = append(this)
+    operator fun HtmlFragment.unaryPlus() = append(this)
+
+    fun element(name: String, attributes: Map<String, String>, block: HtmlDsl.() -> Unit) {
+        element(name, attributes, HtmlDsl().also(block).intoFragment())
+    }
+
+    fun element(name: String, attributes: Map<String, String>, fragment: HtmlFragment) {
+        appendPreEscaped(("<"))
+        append(name)
+
+        for ((key, value) in attributes) {
+            appendPreEscaped((" "))
+            append(key)
+            appendPreEscaped(("=\""))
+            append(value)
+            appendPreEscaped(("\""))
+        }
+
+        appendPreEscaped((">"))
+
+        append(fragment)
+
+        appendPreEscaped(("</"))
+        append(name)
+        appendPreEscaped((">"))
+    }
+
+    fun intoFragment(): HtmlFragment {
+        return HtmlFragment.ofPreEscaped(parts.joinToString("") { it.text })
+    }
+}
+
+
+class HtmlGenerator {
+    private val generators = mutableMapOf<KClass<out MarkdownElement>, HtmlFragmentGenerator<MarkdownElement>>()
+
+    fun <T : MarkdownElement> getGeneratorFor(kClass: KClass<out T>) = generators[kClass] as HtmlFragmentGenerator<T>?
+
+    inline fun <reified T : MarkdownElement> registerFragmentGenerator(noinline outputter: HtmlDsl.(generator: HtmlGenerator, node: T) -> Unit) {
+        registerGeneratorFor(T::class) { gen, node ->
+            HtmlDsl()
+                .apply { outputter.invoke(this, gen, node) }
+                .intoFragment()
+        }
+    }
+
+    inline fun <reified T : MarkdownElement> registerGeneratorFor(outputter: HtmlFragmentGenerator<T>) {
+        registerGeneratorFor(T::class, outputter)
+    }
+
+    fun <T : MarkdownElement> registerGeneratorFor(kClass: KClass<T>, outputter: HtmlFragmentGenerator<T>) {
+        generators[kClass] = outputter as HtmlFragmentGenerator<MarkdownElement>
+    }
+
+    fun registerDefaultGenerators() {
+        registerGeneratorFor<Begin> { _, _ -> HtmlFragment.empty() }
+        registerFragmentGenerator<Header> { gen, header ->
+            element("h${header.level}", mapOf()) {
+                +header.text
+            }
+        }
+        registerFragmentGenerator<Bold> { gen, node ->
+            element("b", mapOf(), gen.generateHtml(node.inner))
+        }
+        registerFragmentGenerator<Italics> { generator, node ->
+            element("em", mapOf(), generator.generateHtml(node.inner))
+        }
+        registerFragmentGenerator<Link> { generator, node ->
+            element("a", mapOf("href" to node.target), generator.generateHtml(node.label ?: Begin()))
+        }
+        registerFragmentGenerator<Paragraph> { generator, node ->
+            element("p", mapOf(), generator.generateHtml(node.format))
+        }
+        registerFragmentGenerator<CodeBlock> { generator, node ->
+            element("pre", mapOf()) {
+                element("code", mapOf("class" to "language-${node.language}")) {
+                    append(node.lines.joinToString("\n"))
+                }
+            }
+        }
+        registerFragmentGenerator<FormatSequence> { generator, node ->
+            for (markdownFormat in node.list) {
+                append(generator.generateHtml(markdownFormat))
+            }
+        }
+        registerFragmentGenerator<Word> { generator, node ->
+            append(node.text)
+        }
+        registerFragmentGenerator<Whitespace> { generator, node ->
+            append(" ")
+        }
+        registerFragmentGenerator<Document> { generator, node ->
+            for (markdownBlock in node.list) {
+                append(generator.generateHtml(markdownBlock))
+            }
+        }
+    }
+
+    fun <T : MarkdownElement> generateHtml(node: T): HtmlFragment {
+        val gen = getGeneratorFor(node::class) ?: error("Missing html generator for $node")
+        return gen.generateHtml(this, node)
+    }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/moe/nea/blog/gen/HtmlTest.kt b/src/test/kotlin/moe/nea/blog/gen/HtmlTest.kt
new file mode 100644
index 0000000..07c5a24
--- /dev/null
+++ b/src/test/kotlin/moe/nea/blog/gen/HtmlTest.kt
@@ -0,0 +1,56 @@
+package moe.nea.blog.gen
+
+import moe.nea.blog.md.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class HtmlTest {
+
+    fun assertGenerator(generatedHtml: String, markdown: MarkdownElement) {
+        val generator = HtmlGenerator()
+        generator.registerDefaultGenerators()
+        assertEquals(generatedHtml, generator.generateHtml(markdown).text)
+    }
+
+    fun assertGeneratorMD(generatedHtml: String, text: String) {
+        val generator = HtmlGenerator()
+        generator.registerDefaultGenerators()
+        assertEquals(generatedHtml, generator.generateHtml(MarkdownParser(text).also { it.addDefaultParsers() }.readDocument()).text)
+    }
+
+    @Test
+    fun testBiggerFile() {
+        assertGeneratorMD(
+            """
+                <h1>Hello World</h1><p></p><p><b><em>lol</em> hehe</b></p><pre><code class="language-java">public class ObjectControllerFactoryManagerProvider&lt;T extends ObjectControllerFactoryManager&lt;T&gt;&gt; {
+                    
+                }</code></pre>
+            """.trimIndent(),
+            """
+            # Hello World
+
+            ***lol*  hehe**
+
+            ```java
+            public class ObjectControllerFactoryManagerProvider<T extends ObjectControllerFactoryManager<T>> {
+                
+            }
+            ```
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testBold() {
+        assertGenerator("<b>Hii</b>", Bold(Word("Hii")))
+    }
+
+    @Test
+    fun testParagraphs() {
+        assertGenerator(
+            "<p>Test <b>Whatever</b></p>",
+            Paragraph(FormatSequence(Word("Test"), Whitespace(), Bold(Word("Whatever"))))
+        )
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/kotlin/moe/nea/blog/md/test/TestItalics.kt b/src/test/kotlin/moe/nea/blog/md/test/TestItalics.kt
index 01bd49e..939ad16 100644
--- a/src/test/kotlin/moe/nea/blog/md/test/TestItalics.kt
+++ b/src/test/kotlin/moe/nea/blog/md/test/TestItalics.kt
@@ -64,6 +64,7 @@ class TestItalics : MarkdownTest() {
     @Test
     fun testFreestandingStarInItalics() {
         assertInlineFormat("<i>left * right</i>", "*left * right*")
+        assertInlineFormat("left * middle ** later", "left * middle ** later")
     }
 
     @Test