Toolkit - Custom Tags Execution while Assembling

This post if part of a series about the File System Toolkit - a custom content delivery API for SDL Tridion.

This post presents the TagFactory in charge with execution of custom tags for the Toolkit Component Presentations.

The content of Dynamic Component Presentations can contain custom tags in the form of <mytag>some body</mytag>. These XML-like nodes are backed by a Java class that is executed when the tag is rendered.

The configuration of tag names and Java class name is done in file toolkit.properties. More information is available in post Installation and Configuration.

The custom tag support uses the following concepts:

• TagFactory -- the entry point into execution of tags for a piece of content;
• TagSupport -- class that associates a tag name with a tag implementation class;
• TagRenderer -- interface that a tag implementation class must implement;

TagRenderer Interface

This is the interface that any tag class must implement. It contains only one method, doTag that is called by the TagSupport class when the tag is executed.

public interface TagRenderer {
    String doTag(String tagBody);
}

A simple example tag follows:

public class MyTag implements TagRenderer {
    public String doTag(String tagBody) {
        return tagBody.toUpperCase();
    }
}

TagSupport Class

This class represents an association between a tag name and a tag implementing class. The only operation this class defines is an execute(String) method. This calls method doTag(String) on the tag implementing class (the one that extends TagRenderer).

Each TagSupport contains a Regular Expression on the name of the tag, using simple pattern like <%1$s[^>]*>(.*)</%1$s>. The Regular Expression identifies the tag XML-like pattern and allows the extraction of the body for further processing.

public String execute(String tagBody) {
    try {
        return clazz.newInstance().doTag(tagBody);
    } catch (IllegalAccessException | InstantiationException e) {
        throw new TagException(e);
    }
}

TagFactory Class

The TagFactory is a singleton that contains an array of TagSupport objects. This array represents all the tags configured in file toolkit.properties.

Method executeTags(String) iterates over each tag and applies its pattern to the String content passed as parameter. For each match of the tag pattern in the content, it calls the tag's execute(String) method passing as parameter the identified tag body.

The original tag is then replaced with the result of its execution.

public String executeTags(String content) {
    StringBuffer result = null;
    StringBuffer buffer = new StringBuffer(content);

    for (TagSupport tag : tags) {
        result = new StringBuffer();
        Matcher matcher = tag.getPattern().matcher(buffer);
        while (matcher.find()) {
            String tagBody = matcher.groupCount() > 0 ? matcher.group(1) : null;
            matcher.appendReplacement(result, tag.execute(tagBody));
        }
        matcher.appendTail(result);
        buffer = result;
    }

    return result == null ? content : result.toString();
}