tessl/maven-org-codehaus-groovy--groovy-templates

Groovy templating engines providing JSP-style scripting, GString expressions, markup builders, and streaming template capabilities for generating dynamic content from templates with variable substitution and control flow

—

Pending

Overview

Eval results

Files

Basic Template Engines

Name: tessl/maven-org-codehaus-groovy--groovy-templates
Author: tessl

The basic template engines (SimpleTemplateEngine and GStringTemplateEngine) provide JSP-style and GString templating capabilities for generating dynamic text content.

SimpleTemplateEngine

The SimpleTemplateEngine processes templates with JSP-style <% %> script blocks and <%= %> expressions, plus GString-style ${...} expressions. It compiles templates to Groovy scripts for execution.

API

class SimpleTemplateEngine extends TemplateEngine {
    SimpleTemplateEngine();
    SimpleTemplateEngine(boolean verbose);
    SimpleTemplateEngine(ClassLoader parentLoader);
    SimpleTemplateEngine(GroovyShell groovyShell);
    
    Template createTemplate(Reader reader) throws CompilationFailedException, ClassNotFoundException, IOException;
    void setVerbose(boolean verbose);
    boolean isVerbose();
    void setEscapeBackslash(boolean escapeBackslash);
    boolean isEscapeBackslash();
}

Template Syntax

Script blocks: <% ... %> - Execute Groovy code
Expression blocks: <%= ... %> - Output expression result
GString expressions: ${...} and $variable - Variable interpolation
Output variable: out - PrintWriter bound to template output

Usage Examples

Basic Template with Mixed Syntax

import groovy.text.SimpleTemplateEngine;
import groovy.text.Template;
import java.util.HashMap;
import java.util.Map;

SimpleTemplateEngine engine = new SimpleTemplateEngine();

String templateText = """
Dear <%= firstname %> ${lastname},

We <% if (accepted) print 'are pleased' else print 'regret' %> \\
to inform you that your paper entitled
'$title' was ${ accepted ? 'accepted' : 'rejected' }.

The conference committee.
""";

Template template = engine.createTemplate(templateText);

Map<String, Object> binding = new HashMap<>();
binding.put("firstname", "Grace");
binding.put("lastname", "Hopper");
binding.put("accepted", true);
binding.put("title", "Groovy for COBOL programmers");

String result = template.make(binding).toString();

Template from File

import java.io.File;
import java.nio.charset.StandardCharsets;

SimpleTemplateEngine engine = new SimpleTemplateEngine();
File templateFile = new File("template.gsp");

// With auto-detected encoding
Template template = engine.createTemplate(templateFile);

// With explicit encoding
Template template2 = engine.createTemplate(templateFile, StandardCharsets.UTF_8);

// Apply binding
String result = template.make(binding).toString();

Verbose Mode for Debugging

SimpleTemplateEngine engine = new SimpleTemplateEngine(true);
// or
engine.setVerbose(true);

// This will print generated script source to System.out
Template template = engine.createTemplate(templateText);

Backslash Escaping

SimpleTemplateEngine engine = new SimpleTemplateEngine();
engine.setEscapeBackslash(true); // Handle \$ and \< sequences

String templateText = "Price: \\$${price}"; // Outputs: Price: $100

Servlet Integration

<!-- web.xml -->
<servlet>
  <servlet-name>SimpleTemplate</servlet-name>
  <servlet-class>groovy.servlet.TemplateServlet</servlet-class>
  <init-param>
    <param-name>template.engine</param-name>
    <param-value>groovy.text.SimpleTemplateEngine</param-value>
  </init-param>
</servlet>

GStringTemplateEngine

The GStringTemplateEngine provides equivalent functionality to SimpleTemplateEngine but uses a streaming closure-based approach, making it more scalable for large templates.

API

class GStringTemplateEngine extends TemplateEngine {
    GStringTemplateEngine();
    GStringTemplateEngine(ClassLoader parentLoader);
    
    Template createTemplate(Reader reader) throws CompilationFailedException, ClassNotFoundException, IOException;
}

Template Syntax

Same as SimpleTemplateEngine:

Script blocks: <% ... %> - Execute Groovy code
Expression blocks: <%= ... %> - Output expression result
GString expressions: ${...} and $variable - Variable interpolation
Output variable: out - PrintWriter bound to template output

Usage Examples

Basic Usage

import groovy.text.GStringTemplateEngine;
import groovy.text.Template;

GStringTemplateEngine engine = new GStringTemplateEngine();

String templateText = """
Hello <%= name %>!
Your balance is ${currency}${balance}.
<% if (balance > 1000) { %>
You qualify for premium service!
<% } %>
""";

Template template = engine.createTemplate(templateText);

Map<String, Object> binding = new HashMap<>();
binding.put("name", "Alice");
binding.put("currency", "$");
binding.put("balance", 1500);

String result = template.make(binding).toString();

Custom Class Loader

ClassLoader customLoader = MyClass.class.getClassLoader();
GStringTemplateEngine engine = new GStringTemplateEngine(customLoader);

Template template = engine.createTemplate(templateSource);

Performance Characteristics

Memory efficient: Uses closures instead of string concatenation
Scalable: Better performance for large templates
Streaming: Generates output incrementally
Garbage collection friendly: Less intermediate string creation

Servlet Integration

<!-- web.xml -->
<servlet>
  <servlet-name>GStringTemplate</servlet-name>
  <servlet-class>groovy.servlet.TemplateServlet</servlet-class>
  <init-param>
    <param-name>template.engine</param-name>
    <param-value>groovy.text.GStringTemplateEngine</param-value>
  </init-param>
</servlet>

Choosing Between SimpleTemplateEngine and GStringTemplateEngine

Use SimpleTemplateEngine when:

Working with small to medium templates
Need verbose debugging output
Require backslash escaping features
Simple deployment requirements

Use GStringTemplateEngine when:

Working with large templates
Memory efficiency is important
High-performance template rendering
Streaming output scenarios

Common Error Handling

Both engines throw the same exceptions:

import groovy.text.TemplateExecutionException;
import groovy.text.TemplateParseException;
import org.codehaus.groovy.control.CompilationFailedException;

try {
    Template template = engine.createTemplate(templateSource);
    String result = template.make(binding).toString();
} catch (TemplateParseException e) {
    // Template syntax error
    System.err.println("Parse error at line " + e.getLineNumber() + 
                      ", column " + e.getColumn() + ": " + e.getMessage());
} catch (CompilationFailedException e) {
    // Groovy compilation error
    System.err.println("Compilation failed: " + e.getMessage());
} catch (TemplateExecutionException e) {
    // Runtime error during template execution
    System.err.println("Execution error at line " + e.getLineNumber() + 
                      ": " + e.getMessage());
} catch (Exception e) {
    // Other errors (IO, ClassNotFound, etc.)
    System.err.println("Template error: " + e.getMessage());
}

Install with Tessl CLI

npx tessl i tessl/maven-org-codehaus-groovy--groovy-templates

docs

basic-template-engines.md

index.md

markup-template-engine.md

streaming-template-engine.md

xml-template-engine.md

tile.json

tessl/maven-org-codehaus-groovy--groovy-templates