Overview

Summary

The Template class is used to build text output in an object-oriented manner, by combining the contents of template file with a hash of values. Named properties of the hash map directly to named {placeholder} variables within the template, which is populated to produce new output.

By separating content (template) and data (object properties) it makes for cleaner and more easily-maintainable code, rather than lots of multiline strings, escaping, and concatenation.

Also see the SimpleTemplate class for a more lightweight approach to templating.

Contents

• Overview
• Summary
• Concept
• API
• Template(uri, data)
• load(uri)
• save(uri, overwrite)
• set(data, value, append)
• indent(indent)
• render()
• clone()
• toString()

Concept

Template file

The Template class is always used in conjunction with physical text files that are stored on disk and loaded via a URI (this is in contrast to the SimpleTemplate class which allows you to simply pass in a template string.

A typical template file might look something like the following:

package {packagePath}
{
    {>imports?}

	class {className}
    {
        function {className}({params?})
        {

        }

		{>methods?}
    }
}

This would populate the above template file with a packagePath, className and methods data, but would leave the optional imports and params placeholders to be deleted automatically.

Placeholder variables

There are three types of placeholder that can be used in templates, indicated by the following syntax:

• {placeholder} - a normal placeholder that will be populated by the same-named value of the data object
• {>indented} - an indented placeholder, which will retain its indentation over multiple lines
• {optional?} - an optional placeholder, which will be removed after rendering if not replaced
• {default=Value} - a default value placeholder, the value of which will be inserted into the document if not replaced

The indented and optional types can also be combined if necessary.

Data object

The data object can be any object or value with properties that can be mapped to the named placeholder variables used in the template. This includes object literals, custom classes, or standard classes such as LibraryItems.

Note that the values of objects can also be other Templates themselves. This allows you to nest Templates inside each other, which is extremely useful when you want to break up a single template file into multiple, discrete parts:

var data =
{
    packagePath: 'some.project',
    className: 'SomeClass',
    methods: [new Template('method.txt', method1), new Template('method.txt', method2)]
}

var template = new Template('class.txt', data);

API

var template = new Template('email.txt', {name:'Dave', greeting:'how are you doing?'});
trace(template.render());

Hello there Dave, how are you doing?

var template = new Template(uri, data);
template
    .load(newURI)
    .render();

template.save(projectURI + 'src/' + package + '.as', true);

var template = new Template(uri);
template
    .set(data) // a data object
    .set('text', 'One two three'); // a named property and value
    .set('text', ' four five six', true); //concatenate data to the previous value

template.indent(2);

var results = template.render();

var copy = template.clone();

trace(template);

[object Template file="user/config/templates/actionscript.as"]