Template::Parser Template::Parser is a LALR parser for compiling template documents.
Download

Template::Parser Ranking & Summary

Template::Parser Tags

Perl module template parser LALR parser LALR template documents

Template::Parser Description

Template::Parser is a LALR parser for compiling template documents. Template::Parser is a LALR parser for compiling template documents.SYNOPSIS use Template::Parser; $parser = Template::Parser- >new(%config); $template = $parser- >parse($text) || die $parser- >error(), "n";The Template::Parser module implements a LALR(1) parser and associated methods for parsing template documents into Perl code.PUBLIC METHODSnew(%params)The new() constructor creates and returns a reference to a new Template::Parser object. A reference to a hash may be supplied as a parameter to provide configuration values. These may include:START_TAG, END_TAGThe START_TAG and END_TAG options are used to specify character sequences or regular expressions that mark the start and end of a template directive. The default values for START_TAG and END_TAG are '' respectively, giving us the familiar directive style: Any Perl regex characters can be used and therefore should be escaped (or use the Perl quotemeta function) if they are intended to represent literal characters. my $parser = Template::Parser- >new({ START_TAG = > quotemeta('< +'), END_TAG = > quotemeta('+ >'), });example: < + INCLUDE foobar + >The TAGS directive can also be used to set the START_TAG and END_TAG values on a per-template file basis. TAG_STYLEThe TAG_STYLE option can be used to set both START_TAG and END_TAG according to pre-defined tag styles. my $parser = Template::Parser- >new({ TAG_STYLE = > 'star', });Available styles are: template (default) template1 or %% ... %% (TT version 1) metatext %% ... %% (Text::MetaText) star (TT alternate) php < ? ... ? > (PHP) asp < % ... % > (ASP) mason < % ... > (HTML::Mason) html < !-- ... -- > (HTML comments)Any values specified for START_TAG and/or END_TAG will over-ride those defined by a TAG_STYLE.The TAGS directive may also be used to set a TAG_STYLE < !-- INCLUDE header -- >PRE_CHOMP, POST_CHOMPAnything outside a directive tag is considered plain text and is generally passed through unaltered (but see the INTERPOLATE option). This includes all whitespace and newlines characters surrounding directive tags. Directives that don't generate any output will leave gaps in the output document.Example: Foo BarOutput: Foo BarThe PRE_CHOMP and POST_CHOMP options can help to clean up some of this extraneous whitespace. Both are disabled by default. my $parser = Template::Parser-E< gt >new({ PRE_CHOMP =E< gt > 1, POST_CHOMP =E< gt > 1, });With PRE_CHOMP set to 1, the newline and whitespace preceding a directive at the start of a line will be deleted. This has the effect of concatenating a line that starts with a directive onto the end of the previous line. Foo E< lt >----------. | ,---(PRE_CHOMP)----' | `-- --. | ,---(POST_CHOMP)---' | `-E< gt > BarWith POST_CHOMP set to 1, any whitespace after a directive up to and including the newline will be deleted. This has the effect of joining a line that ends with a directive onto the start of the next line.If PRE_CHOMP or POST_CHOMP is set to 2, all whitespace including any number of newline will be removed and replaced with a single space. This is useful for HTML, where (usually) a contiguous block of whitespace is rendered the same as a single space.With PRE_CHOMP or POST_CHOMP set to 3, all adjacent whitespace (including newlines) will be removed entirely.These values are defined as CHOMP_NONE, CHOMP_ONE, CHOMP_COLLAPSE and CHOMP_GREEDY constants in the Template::Constants module. CHOMP_ALL is also defined as an alias for CHOMP_ONE to provide backwards compatability with earlier version of the Template Toolkit.Additionally the chomp tag modifiers listed below may also be used for the PRE_CHOMP and POST_CHOMP configuration. my $template = Template-E< gt >new({ PRE_CHOMP =E< lt > '~', POST_CHOMP =E< gt > '-', });PRE_CHOMP and POST_CHOMP can be activated for individual directives by placing a '-' immediately at the start and/or end of the directive. This has the same effect as CHOMP_ONE in removing all whitespace before or after the directive up to and including the newline. The template will be processed as if written: To remove all whitespace including any number of newlines, use the '~' character instead. To collapse all whitespace to a single space, use the '=' character. Here the template is processed as if written: If you have PRE_CHOMP or POST_CHOMP set as configuration options then you can use '+' to disable any chomping options (i.e. leave the whitespace intact) on a per-directive basis. User: With POST_CHOMP set to CHOMP_ONE, the above example would be parsed as if written: User: For reference, the PRE_CHOMP and POST_CHOMP configuration options may be set to any of the following: Constant Value Tag Modifier ---------------------------------- CHOMP_NONE 0 + CHOMP_ONE 1 - CHOMP_COLLAPSE 2 = CHOMP_GREEDY 3 ~INTERPOLATEThe INTERPOLATE flag, when set to any true value will cause variable references in plain text (i.e. not surrounded by START_TAG and END_TAG) to be recognised and interpolated accordingly. my $parser = Template::Parser- >new({ INTERPOLATE = > 1, });Variables should be prefixed by a '$' to identify them. Curly braces can be used in the familiar Perl/shell style to explicitly scope the variable name where required. # INTERPOLATE = > 0 < a href="http:///" > < img src="/help.gif" >< /a > # INTERPOLATE = > 1 < a href="http://$server/$help" > < img src="$images/help.gif" >< /a > $myorg.name # explicit scoping with { } < img src="$images/${icon.next}.gif" >Note that a limitation in Perl's regex engine restricts the maximum length of an interpolated template to around 32 kilobytes or possibly less. Files that exceed this limit in size will typically cause Perl to dump core with a segmentation fault. If you routinely process templates of this size then you should disable INTERPOLATE or split the templates in several smaller files or blocks which can then be joined backed together via PROCESS or INCLUDE.ANYCASEBy default, directive keywords should be expressed in UPPER CASE. The ANYCASE option can be set to allow directive keywords to be specified in any case. # ANYCASE = > 0 (default) # OK # ERROR # OK, 'include' is a variable # ANYCASE = > 1 # OK # OK # ERROR, 'include' is reserved wordOne side-effect of enabling ANYCASE is that you cannot use a variable of the same name as a reserved word, regardless of case. The reserved words are currently: GET CALL SET DEFAULT INSERT INCLUDE PROCESS WRAPPER IF UNLESS ELSE ELSIF FOR FOREACH WHILE SWITCH CASE USE PLUGIN FILTER MACRO PERL RAWPERL BLOCK META TRY THROW CATCH FINAL NEXT LAST BREAK RETURN STOP CLEAR TO STEP AND OR NOT MOD DIV ENDThe only lower case reserved words that cannot be used for variables, regardless of the ANYCASE option, are the operators: and or not mod divV1DOLLARIn version 1 of the Template Toolkit, an optional leading '$' could be placed on any template variable and would be silently ignored. # VERSION 1 === === To interpolate a variable value the '${' ... '}' construct was used. Typically, one would do this to index into a hash array when the key value was stored in a variable.example: my $vars = { users = > { aba = > { name = > 'Alan Aardvark', ... }, abw = > { name = > 'Andy Wardley', ... }, ... }, uid = > 'aba', ... }; $template- >process('user/home.html', $vars) || die $template- >error(), "n";'user/home.html': # users.aba Name: # Alan AardvarkThis was inconsistent with double quoted strings and also the INTERPOLATE mode, where a leading '$' in text was enough to indicate a variable for interpolation, and the additional curly braces were used to delimit variable names where necessary. Note that this use is consistent with UNIX and Perl conventions, among others. # double quoted string interpolation # INTERPOLATE = 1 < img src="$images/help.gif" >< /a > < img src="$images/${icon.next}.gif" >For version 2, these inconsistencies have been removed and the syntax clarified. A leading '$' on a variable is now used exclusively to indicate that the variable name should be interpolated (e.g. subsituted for its value) before being used. The earlier example from version 1: # VERSION 1 Name: can now be simplified in version 2 as: # VERSION 2 Name: The leading dollar is no longer ignored and has the same effect of interpolation as '${' ... '}' in version 1. The curly braces may still be used to explicitly scope the interpolated variable name where necessary.e.g. Name: The rule applies for all variables, both within directives and in plain text if processed with the INTERPOLATE option. This means that you should no longer (if you ever did) add a leading '$' to a variable inside a directive, unless you explicitly want it to be interpolated.One obvious side-effect is that any version 1 templates with variables using a leading '$' will no longer be processed as expected. Given the following variable definitions, version 1 would interpret the following as: # VERSION 1 = > = > barwhereas version 2 interprets it as: # VERSION 2 = > = > = > bazIn version 1, the '$' is ignored and the value for the variable 'foo' is retrieved and printed. In version 2, the variable '$foo' is first interpolated to give the variable name 'bar' whose value is then retrieved and printed.The use of the optional '$' has never been strongly recommended, but to assist in backwards compatibility with any version 1 templates that may rely on this "feature", the V1DOLLAR option can be set to 1 (default: 0) to revert the behaviour and have leading '$' characters ignored. my $parser = Template::Parser- >new({ V1DOLLAR = > 1, });GRAMMARThe GRAMMAR configuration item can be used to specify an alternate grammar for the parser. This allows a modified or entirely new template language to be constructed and used by the Template Toolkit.Source templates are compiled to Perl code by the Template::Parser using the Template::Grammar (by default) to define the language structure and semantics. Compiled templates are thus inherently "compatible" with each other and there is nothing to prevent any number of different template languages being compiled and used within the same Template Toolkit processing environment (other than the usual time and memory constraints).The Template::Grammar file is constructed from a YACC like grammar (using Parse::YAPP) and a skeleton module template. These files are provided, along with a small script to rebuild the grammar, in the 'parser' sub-directory of the distribution. You don't have to know or worry about these unless you want to hack on the template language or define your own variant. There is a README file in the same directory which provides some small guidance but it is assumed that you know what you're doing if you venture herein. If you grok LALR parsers, then you should find it comfortably familiar.By default, an instance of the default Template::Grammar will be created and used automatically if a GRAMMAR item isn't specified. use MyOrg::Template::Grammar; my $parser = Template::Parser- >new({ GRAMMAR = MyOrg::Template::Grammar- >new(); });DEBUGThe DEBUG option can be used to enable various debugging features of the Template::Parser module. use Template::Constants qw( :debug ); my $template = Template- >new({ DEBUG = > DEBUG_PARSER | DEBUG_DIRS, });The DEBUG value can include any of the following. Multiple values should be combined using the logical OR operator, '|'.DEBUG_PARSERThis flag causes the Template::Parser to generate debugging messages that show the Perl code generated by parsing and compiling each template.DEBUG_DIRSThis option causes the Template Toolkit to generate comments indicating the source file, line and original text of each directive in the template. These comments are embedded in the template output using the format defined in the DEBUG_FORMAT configuration item, or a simple default format if unspecified.For example, the following template fragment: Hello Worldwould generate this output: ## input text line 1 : ## Hello ## input text line 2 : World ## Worldparse($text)The parse() method parses the text passed in the first parameter and returns a reference to a hash array of data defining the compiled representation of the template text, suitable for passing to the Template::Document new() constructor method. On error, undef is returned.Example: $data = $parser- >parse($text) || die $parser- >error();The $data hash reference returned contains a BLOCK item containing the compiled Perl code for the template, a DEFBLOCKS item containing a reference to a hash array of sub-template BLOCKs defined within in the template, and a METADATA item containing a reference to a hash array of metadata values defined in META tags.Requirements:· Perl Requirements: · Perl

Template::Parser Related Software