sirius.tagliatelle

Class Tagliatelle

java.lang.Object

sirius.tagliatelle.Tagliatelle

public class Tagliatelle
extends Object

Provides statically compiled and optimized templates to generate HTML, XML and text files.

Helps to resolve and compile templates and also to generate a context used to render their output.

Field Summary

Fields

Modifier and Type	Field and Description
static sirius.kernel.health.Log	LOG Logs everything related to resolving, compiling and rendering tagliatelle templates.
protected static String	PRAGMA_ALIAS

Constructor Summary

Constructors

Constructor and Description
Tagliatelle()

Method Summary

Modifier and Type	Method and Description
CompilationContext	createCompilationContext(String path, Resource resource, CompilationContext parent) Creates a new CompilationContext for the given path and resource.
List<Object>	createEnvironment() Creates a new list of global variables used to initialize a global render context.
GlobalRenderContext	createRenderContext() Creates a new render context.
static void	ensureProperTemplatePath(String path) For security reasons we only invoke templates that end with .pasta.
Map<String,Class<?>>	getClassAliases() Provides all known class aliases.
List<Template>	getCompiledTemplates() Provides a list of all currently compiled templates.
List<sirius.kernel.commons.Tuple<String,Class<?>>>	getGlobalVariables() Returns the names and types of the known global variables to assist the Compiler.
List<sirius.kernel.commons.Tuple<String,String>>	getTagLibs() Returns a list of all tag lib prefixes and descriptions.
sirius.kernel.commons.MultiMap<String,String>	getTagLibTags() Returns all taglibs and all tags within this taglib.
static boolean	isAssignable(Object from, Class<?> to) Determines if the type to is assignable from the given object.
static boolean	isAssignableTo(Class<?> from, Class<?> to) Determines if the type to is assignable from the given type from.
boolean	isTaglib(String prefix) Determines if a taglib with the given prefix exists.
Optional<Template>	resolve(String path) Resolves the given path using Resources and compiles it into a Template.
Optional<Template>	resolve(String path, CompilationContext parentContext) Resolves the given path using Resources and compiles it into a Template.
String	resolveTagName(String qualifiedTagName) Computes the effective path name for a tag.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

public static final sirius.kernel.health.Log LOG

Logs everything related to resolving, compiling and rendering tagliatelle templates.

PRAGMA_ALIAS

protected static final String PRAGMA_ALIAS

See Also:

Constant Field Values

Constructor Detail

Tagliatelle

public Tagliatelle()

Method Detail

getTagLibTags

public sirius.kernel.commons.MultiMap<String,String> getTagLibTags()

Returns all taglibs and all tags within this taglib.

Returns:

a multimap containing all taglibs (prefix) and their tags

getTagLibs

public List<sirius.kernel.commons.Tuple<String,String>> getTagLibs()

Returns a list of all tag lib prefixes and descriptions.

Returns:

a list of tuples containing the taglib prefix and a short description

isTaglib

public boolean isTaglib(String prefix)

Determines if a taglib with the given prefix exists.

Parameters:

prefix - the prefix to check

Returns:

true if a taglib with the given prefix exists, false otherwise

getClassAliases

public Map<String,Class<?>> getClassAliases()

Provides all known class aliases.

Returns:

an unmodifyable map of all known aliases for Java classes.

createEnvironment

public List<Object> createEnvironment()

Creates a new list of global variables used to initialize a global render context.

Returns:

a new list of global variables

getGlobalVariables

public List<sirius.kernel.commons.Tuple<String,Class<?>>> getGlobalVariables()

Returns the names and types of the known global variables to assist the Compiler.

Returns:

the list of known global variables and their types

createCompilationContext

public CompilationContext createCompilationContext(@Nonnull
                                                   String path,
                                                   @Nullable
                                                   Resource resource,
                                                   @Nullable
                                                   CompilationContext parent)

Creates a new CompilationContext for the given path and resource.

Parameters:

path - the path of the template being compiled

resource - the actual resource which was used to determine the source code of the template

parent - if the compilation was started while compiling another template, its context is given here. This is mainly used to detect and abort cyclic dependencies at compile time.

Returns:

a new compilation context for the given resource

createRenderContext

public GlobalRenderContext createRenderContext()

Creates a new render context.

Returns:

a context used to render a template

isAssignable

public static boolean isAssignable(Object from,
                                   Class<?> to)

Determines if the type to is assignable from the given object.

In contrast to Class.isAssignableFrom(Class), this also handles autoboxing appropriately.

Parameters:

from - the object to assign

to - the type to assign to

Returns:

true if the object is assignable, false otherwise

isAssignableTo

public static boolean isAssignableTo(Class<?> from,
                                     Class<?> to)

Determines if the type to is assignable from the given type from.

In contrast to Class.isAssignableFrom(Class), this also handles autoboxing appropriately.

Parameters:

from - the type to assign

to - the type to assign to

Returns:

true if the object is assignable, false otherwise

resolve

public Optional<Template> resolve(String path)
                           throws CompileException

Resolves the given path using Resources and compiles it into a Template.

Parameters:

path - the path to resolve

Returns:

the appropriate template or an empty template if no matching Resource was found.

Throws:

CompileException - in case of one or more compilation errors in the template

resolve

public Optional<Template> resolve(String path,
                                  @Nullable
                                  CompilationContext parentContext)
                           throws CompileException

Resolves the given path using Resources and compiles it into a Template.

If the template is resolved as part of another compilation process, the context is passed in as parentContext to detect and abort cyclic references.

Parameters:

path - the path to resolve

parentContext - the outer compilation context which is in charge of compiling the callee

Returns:

the appropriate template or an empty template if no matching Resource was found.

Throws:

CompileException - in case of one or more compilation errors in the template

ensureProperTemplatePath

public static void ensureProperTemplatePath(String path)

For security reasons we only invoke templates that end with .pasta.

Otherwise one could customize a template and try to include a configuration file or class file and therefore obtain private data.

Parameters:

path - the path to check

resolveTagName

public String resolveTagName(String qualifiedTagName)

Computes the effective path name for a tag.

A template for a tag named <prefix:tagName> is expected to reside in /taglib/prefix/tagName.html.pasta.

Parameters:

qualifiedTagName - the qualified tag name, e.g. prefix:tagName

Returns:

the template path, e.g. /taglib/prefix/tagName.html.pasta

getCompiledTemplates

public List<Template> getCompiledTemplates()

Provides a list of all currently compiled templates.

Note that this directly accesses an inner cache. Therefore some templates which were rendered some time ago, might have been dropped out of the cache and will therefore not occur in this list.

Returns:

a list of all compiled templates