Template Engines

import groovy.text.markup.*

def engine = new MarkupTemplateEngine()
def tpl = engine.createTemplate '''\
xmlDeclaration()
log(zone: zone) {
    readings.each { r ->
        reading(sensor: r.sensor, temperature: r.temperature)
    }
}
'''
def model = [zone: 'bench', readings: [[sensor: 'bench-1', temperature: 18.5], [sensor: 'bench-2', temperature: 20.0]]]
println tpl.make(model)

def html = engine.createTemplate '''\
yieldUnescaped '<!DOCTYPE html>'
html(lang: 'en') {
    head { title("Zone $zone") }
    body {
        h1(zone)
        table {
            readings.each { r ->
                tr { td(r.sensor); td(r.temperature) }
            }
        }
        comment 'generated'
        p {
            yield 'Raw: <b>'
            yieldUnescaped ' unescaped: <b>'
        }
    }
}
'''
println html.make(model)

<?xml version='1.0'?>
<log zone='bench'><reading sensor='bench-1' temperature='18.5'/><reading sensor='bench-2' temperature='20.0'/></log>
<!DOCTYPE html><html lang='en'><head><title>Zone bench</title></head><body><h1>bench</h1><table><tr><td>bench-1</td><td>18.5</td></tr><tr><td>bench-2</td><td>20.0</td></tr></table><!--generated--><p>Raw: &lt;b&gt; unescaped: <b></p></body></html>

import groovy.text.markup.*

def cfg = new TemplateConfiguration(autoIndent: true, autoNewLine: true, useDoubleQuotes: true,
                                    expandEmptyElements: true, declarationEncoding: 'UTF-8')
def pretty = new MarkupTemplateEngine(cfg).createTemplate '''\
xmlDeclaration()
log {
    readings.each { r ->
        reading(sensor: r.sensor)
        empty()
    }
}
'''
println pretty.make(zone: 'bench', readings: [[sensor: 'bench-1'], [sensor: 'bench-2']])

<?xml version="1.0" encoding="UTF-8"?>
<log>
    <reading sensor="bench-1"></reading><empty></empty><reading sensor="bench-2"></reading><empty></empty>
</log>

// views/layout-main.tpl
html {
    head { title(title) }
    body {
        h1(title)
        bodyContents()
    }
}

// views/report.tpl
layout 'layout-main.tpl',
    title: "Zone $zone",
    bodyContents: contents {
        ul {
            readings.each { r ->
                fragment "li(text)", text: "${r.sensor}: ${r.temperature}"
            }
        }
        p { includeUnescaped 'footer.txt' }
        p { includeEscaped 'footer.txt' }
    }

import groovy.text.markup.*

def cfg = new TemplateConfiguration(autoNewLine: true, autoIndent: true)
def engine = new MarkupTemplateEngine(this.class.classLoader, new File('views'), cfg)
def model = [zone: 'bench', readings: [[sensor: 'bench-1', temperature: 18.5], [sensor: 'bench-2', temperature: 20.0]]]
println engine.createTemplateByPath('report.tpl').make(model)

<html>
    <head><title>Zone bench</title></head><body>
        <h1>Zone bench</h1><ul><li>bench-1: 18.5</li><li>bench-2: 20.0</li></ul><p>Next check: <b>noon</b></p><p>Next check: &lt;b&gt;noon&lt;/b&gt;</p>
    </body>
</html>

// views/inherit.tpl
layout 'layout-main.tpl', true,
    bodyContents: contents { p('inherits the title') }

<html>
    <head><title>Inherited title</title></head><body>
        <h1>Inherited title</h1><p>inherits the title</p>
    </body>
</html>

import groovy.text.markup.*

def src = 'div(note)'
def model = [note: 'Water <script>alert(1)</script> now']
println new MarkupTemplateEngine().createTemplate(src).make(model)
println new MarkupTemplateEngine(new TemplateConfiguration(autoEscape: true)).createTemplate(src).make(model)
println new MarkupTemplateEngine(new TemplateConfiguration(autoEscape: true)).createTemplate('div(unescaped.note)').make(model)

<div>Water <script>alert(1)</script> now</div>
<div>Water &lt;script&gt;alert(1)&lt;/script&gt; now</div>
<div>Water <script>alert(1)</script> now</div>

import groovy.text.markup.*

def e = new MarkupTemplateEngine()
println e.createTemplate('p("See ${a(href: "#top", "top")} now")').make([:])
println e.createTemplate('p("See ${stringOf { a(href: "#top", "top") }} now")').make([:])
println e.createTemplate('p("See ${$a(href: "#top", "top")} now")').make([:])
println e.createTemplate('p { yield "See "; a(href: "#top", "top"); yield " now" }').make([:])

<a href='#top'>top</a><p>See  now</p>
<p>See <a href='#top'>top</a> now</p>
<p>See <a href='#top'>top</a> now</p>
<p>See <a href='#top'>top</a> now</p>

import groovy.text.markup.*

def cfg = new TemplateConfiguration()
def engine = new MarkupTemplateEngine(this.class.classLoader, new File('views'), cfg)
println engine.createTemplateByPath('hello.tpl').make([:])
println engine.createTemplateByPath('greet.tpl').make([:])
println engine.createTemplateByPath('hello_fr_FR.tpl').make([:])
cfg.locale = Locale.FRANCE
def fr = new MarkupTemplateEngine(this.class.classLoader, new File('views'), cfg)
println fr.createTemplateByPath('greet.tpl').make([:])

<p>Default text</p>
<p>Default text</p>
<p>Texte en français</p>
<p>Texte en français</p>

import groovy.text.markup.*

abstract class GreenhouseTemplate extends BaseTemplate {
    GreenhouseTemplate(MarkupTemplateEngine engine, Map model, Map<String, String> modelTypes, TemplateConfiguration cfg) {
        super(engine, model, modelTypes, cfg)
    }
    String celsius(def value) { "${value} °C" }
}

def cfg = new TemplateConfiguration(baseTemplateClass: GreenhouseTemplate)
def engine = new MarkupTemplateEngine(this.class.classLoader, cfg)
println engine.createTemplate('p(celsius(temperature))').make(temperature: 18.5)

<p>18.5 °C</p>

import groovy.text.markup.*

class Plant { String name; String zone }

def engine = new MarkupTemplateEngine(this.class.classLoader, new TemplateConfiguration())
def plants = [new Plant(name: 'tomato', zone: 'bench-1')]

def ok = engine.createTemplate 'ul { plants.each { p -> li("${p.name} in ${p.zone}") } }'
println ok.make(plants: plants)

// untyped: the mistake only shows up on rendering
def bad = 'ul { plants.each { p -> li(p.nme) } }'
try { println engine.createTemplate(bad).make(plants: plants) } catch (e) { println 'render: ' + e.class.simpleName + ': ' + e.message.readLines()[0] }

// typed: fails at compile time
try {
    engine.createTypeCheckedModelTemplate(new StringReader(bad), [plants: 'List<Plant>'])
} catch (e) { println 'compile: ' + e.class.simpleName + ': ' + e.message.readLines().find { it.contains('nme') && it.contains('No such') } }

// types declared in the template
def inline = '''\
modelTypes = {
    List<Plant> plants
}
ul { plants.each { p -> li(p.nme) } }
'''
try { engine.createTemplate(inline) } catch (e) { println 'inline: ' + e.message.readLines().find { it.contains('nme') && it.contains('No such') } }
println engine.createTemplate(inline.replace('nme', 'name')).make(plants: plants)

<ul><li>tomato in bench-1</li></ul>
render: MissingPropertyException: No such property: nme for class: Plant
compile: MultipleCompilationErrorsException: GeneratedMarkupTemplate2: 1: [Static type checking] - No such property: nme for class: Plant
inline: GeneratedMarkupTemplate3: 4: [Static type checking] - No such property: nme for class: Plant
<ul><li>tomato</li></ul>