or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

basic-template-engines.mdindex.mdmarkup-template-engine.mdstreaming-template-engine.mdxml-template-engine.md
tile.json

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

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.codehaus.groovy/groovy-templates@3.0.x

To install, run

npx @tessl/cli install tessl/maven-org-codehaus-groovy--groovy-templates@3.0.0

index.mddocs/

Groovy Templates

Groovy Templates provides a comprehensive set of template engines for generating dynamic content from templates using various approaches. The library supports JSP-style scripting syntax with <% %> blocks and <%= %> expressions, GString-style variable interpolation, XML template processing with DOM manipulation, markup builders for generating structured content, and high-performance streaming templates for large-scale content generation.

Package Information

  • Package Name: groovy-templates
  • Package Type: Maven
  • Language: Java/Groovy
  • Installation: Add to your Gradle build: implementation 'org.codehaus.groovy:groovy-templates:3.0.25'
  • Maven: 
    <dependency>
  <groupId>org.codehaus.groovy</groupId>
  <artifactId>groovy-templates</artifactId>
  <version>3.0.25</version>
</dependency>

Core Imports

import groovy.text.*;
import groovy.text.markup.*;

Basic Usage

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

// Create template engine
SimpleTemplateEngine engine = new SimpleTemplateEngine();

// Create template from string
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);

// Create binding data
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");

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

Architecture

Groovy Templates follows a template engine pattern where:

  1. TemplateEngine - Factory for creating Template instances from various sources
  2. Template - Compiled template that can be bound with data and executed
  3. Writable - Result that can be written to any Writer or converted to String

The library provides multiple template engine implementations optimized for different use cases, from simple text templating to complex XML/HTML generation with type safety.

Capabilities

Basic Template Engines

Core template engines supporting JSP-style and GString syntax for simple to moderate templating needs.

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();
}
class GStringTemplateEngine extends TemplateEngine {
    GStringTemplateEngine();
    GStringTemplateEngine(ClassLoader parentLoader);
    
    Template createTemplate(Reader reader) throws CompilationFailedException, ClassNotFoundException, IOException;
}

Basic Template Engines

XML Template Engine

Specialized template engine for XML document generation with support for GSP tags and automatic XML formatting.

class XmlTemplateEngine extends TemplateEngine {
    XmlTemplateEngine() throws SAXException, ParserConfigurationException;
    XmlTemplateEngine(String indentation, boolean validating) throws SAXException, ParserConfigurationException;
    XmlTemplateEngine(XmlParser xmlParser, ClassLoader parentLoader);
    XmlTemplateEngine(XmlParser xmlParser, GroovyShell groovyShell);
    
    Template createTemplate(Reader reader) throws CompilationFailedException, ClassNotFoundException, IOException;
    void setIndentation(String indentation);
    String getIndentation();
    void setConfigurePrinter(Closure configurePrinter);
}

XML Template Engine

Streaming Template Engine

High-performance template engine optimized for large templates (>64k) with better error reporting and memory efficiency.

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

Streaming Template Engine

Markup Template Engine

Advanced type-safe template engine for XML/HTML generation with compile-time checking, template inheritance, and layout support.

class MarkupTemplateEngine extends TemplateEngine {
    MarkupTemplateEngine();
    MarkupTemplateEngine(TemplateConfiguration config);
    MarkupTemplateEngine(ClassLoader parentLoader, TemplateConfiguration config);
    MarkupTemplateEngine(ClassLoader parentLoader, TemplateConfiguration config, TemplateResolver resolver);
    
    Template createTemplate(Reader reader) throws CompilationFailedException, ClassNotFoundException, IOException;
}
class TemplateConfiguration {
    TemplateConfiguration();
    TemplateConfiguration(TemplateConfiguration that);
    
    // XML/HTML output configuration
    void setDeclarationEncoding(String declarationEncoding);
    String getDeclarationEncoding();
    void setExpandEmptyElements(boolean expandEmptyElements);
    boolean isExpandEmptyElements();
    void setUseDoubleQuotes(boolean useDoubleQuotes);
    boolean isUseDoubleQuotes();
    void setNewLineString(String newLineString);
    String getNewLineString();
    
    // Content processing configuration
    void setAutoEscape(boolean autoEscape);
    boolean isAutoEscape();
    void setAutoIndent(boolean autoIndent);
    boolean isAutoIndent();
    void setAutoIndentString(String autoIndentString);
    String getAutoIndentString();
    void setAutoNewLine(boolean autoNewLine);
    boolean isAutoNewLine();
    
    // Template system configuration
    void setBaseTemplateClass(Class<? extends BaseTemplate> baseTemplateClass);
    Class<? extends BaseTemplate> getBaseTemplateClass();
    void setLocale(Locale locale);
    Locale getLocale();
    void setCacheTemplates(boolean cacheTemplates);
    boolean isCacheTemplates();
}

Markup Template Engine

Core Interfaces

TemplateEngine

Abstract base class for all template engines providing common template creation methods.

abstract class TemplateEngine {
    abstract Template createTemplate(Reader reader) throws CompilationFailedException, ClassNotFoundException, IOException;
    Template createTemplate(String templateText) throws CompilationFailedException, ClassNotFoundException, IOException;
    Template createTemplate(File file) throws CompilationFailedException, ClassNotFoundException, IOException;
    Template createTemplate(File file, Charset cs) throws CompilationFailedException, ClassNotFoundException, IOException;
    Template createTemplate(URL url) throws CompilationFailedException, ClassNotFoundException, IOException;
    Template createTemplate(URL url, Charset cs) throws CompilationFailedException, ClassNotFoundException, IOException;
}

Template

Interface representing a compiled template that can be bound with data and executed.

interface Template {
    Writable make();
    Writable make(Map binding);
}

TemplateResolver

Interface for template resolvers used by MarkupTemplateEngine to locate template resources.

interface TemplateResolver {
    void configure(ClassLoader templateClassLoader, TemplateConfiguration configuration);
    URL resolveTemplate(String templatePath) throws IOException;
}

Exception Handling

class TemplateExecutionException extends Exception {
    TemplateExecutionException(int lineNumber);
    TemplateExecutionException(int lineNumber, String message);
    TemplateExecutionException(int lineNumber, String message, Throwable cause);
    TemplateExecutionException(int lineNumber, Throwable cause);
    
    int getLineNumber();
}
class TemplateParseException extends RuntimeException {
    TemplateParseException(int lineNumber, int column);
    TemplateParseException(String message, int lineNumber, int column);
    TemplateParseException(String message, Throwable cause, int lineNumber, int column);
    TemplateParseException(Throwable t, int lineNumber, int column);
    
    int getLineNumber();
    int getColumn();
}

Types

// From Groovy Lang
interface Writable {
    Writer writeTo(Writer writer) throws IOException;
}

// Standard Java types used throughout
interface Map<K,V> { }
interface Reader { }
interface Writer { }
class File { }
class URL { }
class Charset { }
class Locale { }
class ClassLoader { }