🔀 Merge next

[Sone.git] / src / main / kotlin / net / pterodactylus / sone / template / LinkedElementRenderFilter.kt

diff --git a/src/main/kotlin/net/pterodactylus/sone/template/LinkedElementRenderFilter.kt b/src/main/kotlin/net/pterodactylus/sone/template/LinkedElementRenderFilter.kt
index e15f68b..5cc602c 100644 (file)
--- a/src/main/kotlin/net/pterodactylus/sone/template/LinkedElementRenderFilter.kt
+++ b/src/main/kotlin/net/pterodactylus/sone/template/LinkedElementRenderFilter.kt
@@ -1,25 +1,18 @@
 package net.pterodactylus.sone.template
 
-import net.pterodactylus.sone.core.LinkedElement
-import net.pterodactylus.util.template.Filter
-import net.pterodactylus.util.template.TemplateContext
-import net.pterodactylus.util.template.TemplateContextFactory
-import net.pterodactylus.util.template.TemplateParser
-import java.io.StringReader
-import java.io.StringWriter
-import javax.inject.Inject
+import net.pterodactylus.sone.core.*
+import net.pterodactylus.sone.utils.*
+import net.pterodactylus.util.template.*
+import java.io.*
 
 /**
  * Renders all kinds of [LinkedElement]s.
  */
-class LinkedElementRenderFilter @Inject constructor(private val templateContextFactory: TemplateContextFactory): Filter {
+class LinkedElementRenderFilter : Filter {
 
-       companion object {
-               private val loadedImageTemplate = """<%include linked/image.html>""".parse()
-               private val loadedHtmlPageTemplate = """<%include linked/html-page.html>""".parse()
-               private val notLoadedImageTemplate = """<%include linked/notLoaded.html>""".parse()
-
-               private fun String.parse() = StringReader(this).use { TemplateParser.parse(it) }!!
+       private val templateContextFactory = TemplateContextFactory().apply {
+               addFilter("html", HtmlFilter())
+               addProvider(ClassPathTemplateProvider(LinkedElementRenderFilter::class.java, "/templates/"))
        }
 
        override fun format(templateContext: TemplateContext?, data: Any?, parameters: Map<String, Any?>?) =
@@ -27,32 +20,45 @@ class LinkedElementRenderFilter @Inject constructor(private val templateContextF
                                data is LinkedElement && data.loading -> renderNotLoadedLinkedElement(data)
                                data is LinkedElement && data.properties["type"] == "image" -> renderLinkedImage(data)
                                data is LinkedElement && data.properties["type"] == "html" -> renderHtmlPage(data)
+                               data is LinkedElement && data.properties["type"] == "audio" -> renderAudioPlayer(data)
                                else -> null
                        }
 
        private fun renderLinkedImage(linkedElement: LinkedElement) =
-                       StringWriter().use {
-                               val templateContext = templateContextFactory.createTemplateContext()
+                       renderTemplate(loadedImageTemplate) { templateContext ->
                                templateContext["link"] = linkedElement.link
-                               loadedImageTemplate.render(templateContext, it)
-                               it
-                       }.toString()
+                       }
 
        private fun renderHtmlPage(linkedElement: LinkedElement) =
-                       StringWriter().use {
-                               val templateContext = templateContextFactory.createTemplateContext()
+                       renderTemplate(loadedHtmlPageTemplate) { templateContext ->
                                templateContext["link"] = linkedElement.link
                                templateContext["title"] = linkedElement.properties["title"] ?: "No title"
                                templateContext["description"] = linkedElement.properties["description"] ?: "No description"
-                               it.also { loadedHtmlPageTemplate.render(templateContext, it) }
-                       }.toString()
+                       }
+
+       private fun renderAudioPlayer(linkedElement: LinkedElement) =
+                       renderTemplate(loadedAudioTemplate) { templateContext ->
+                               templateContext["link"] = linkedElement.link
+                       }
 
        private fun renderNotLoadedLinkedElement(linkedElement: LinkedElement) =
-                       StringWriter().use {
-                               val templateContext = templateContextFactory.createTemplateContext()
+                       renderTemplate(notLoadedImageTemplate) { templateContext ->
                                templateContext["link"] = linkedElement.link
-                               notLoadedImageTemplate.render(templateContext, it)
-                               it
+                       }
+
+       private fun renderTemplate(template: Template, fillTemplateContext: (TemplateContext) -> Unit) =
+                       StringWriter().use { stringWriter ->
+                               stringWriter.also {
+                                       templateContextFactory.createTemplateContext().also { templateContext ->
+                                               fillTemplateContext(templateContext)
+                                               template.render(templateContext, stringWriter)
+                                       }
+                               }
                        }.toString()
 
 }
+
+private val loadedImageTemplate = """<%include linked/image.html>""".asTemplate()
+private val loadedHtmlPageTemplate = """<%include linked/html-page.html>""".asTemplate()
+private val loadedAudioTemplate = """<%include linked/audio.html>""".asTemplate()
+private val notLoadedImageTemplate = """<%include linked/notLoaded.html>""".asTemplate()