Petal - Perl Template Attribute Language - TAL for Perl!
From version 2.00 onwards Petal *requires* that you use well-formed XML. This is because Petal now uses MKDoc::XML::TreeBuilder rather than HTML::TreeBuilder and XML::Parser.
In particular, this version of Petal *CAN* break backwards compatibility if you were using Petal's HTML mode will non well formed XHTML.
If you still want to use broken XHTML, you can Petal 2.00 in conjunction with Petal::Parser::HTB which has been created for this purpose.
in your Perl code:
use Petal; my $template = new Petal ('foo.xhtml'); print $template->process (bar => 'BAZ');
in foo.xhtml
<html xmlns:tal="http://purl.org/petal/1.0/"> <body tal:content="bar">Dummy Content</body> </html>
and you get something like:
<html> <body>BAZ</body> </html>
Petal is a XML based templating engine that is able to process any kind of XML, XHTML and HTML.
Petal borrows a lot of good ideas from the Zope Page Templates TAL specification, it is very well suited for the creation of WYSIWYG XHTML editable templates.
The idea is to further enforce the separation of logic from presentation. With Petal, graphic designers can use their favorite WYSIWYG editor to easily edit templates without having to worry about the loops and ifs which happen behind the scene.
Although this is not mandatory, Petal templates should include use the namespace http://purl.org/petal/1.0/. Example:
<html xml:lang="en" lang="en" xmlns="http://www.w3.org/1999/xhtml" xmlns:tal="http://purl.org/petal/1.0/"> Blah blah blah... Content of the file More blah blah... </html>
If you do not specify the namespace, Petal will by default try to use the petal: prefix. However, in all the examples of this POD we'll use the tal: prefix to avoid too much typing.
petal:
tal:
Let's say you have the following Perl code:
use Petal; local $Petal::OUTPUT = 'XHTML'; my $template = new Petal ('foo.xhtml'); template->process ( my_var => my_var() );
some_object() is a subroutine that returns some kind of object, may it be a scalar, object, array referebce or hash reference. Let's see what we can do...
<!--? This is a template comment. It will not appear in the output --> <html xmlns:tal="http://purl.org/petal/1.0/"> <body> This is the variable 'my_var' : ${my_var}. </body> </html>
And if my_var contained Hello World, Petal would have outputted:
my_var
<html> <body> This is the variable 'my_var' : Hello World. </body> </html>
Now let's say that my_var is a hash reference as follows:
$VAR1 = { hello_world => 'Hello, World' }
To output the same result, you would write:
This is the variable 'my_var' : ${my_var/hello_world}.
The problem with the above page is that when you edit it with a WYSIWYG editor, or simply open it in your browser, you will see:
Ideally you don't want your graphic designers to worry about variable names... and that's where TAL kicks in. Using TAL you can do:
This is the variable 'my_var' : <span tal:replace="my_var/hello_world">Hola, Mundo!</span>
Now you can open your template in any WYSIWYG tool (mozilla composer, frontpage, dreamweaver, adobe golive...) and work with less risk of damaging your petal commands.
Let's now say that my_var is actually an object with a method hello_world() that returns Hello World. To output the same result, your line:
<span tal:replace="my_var/hello_world">Hola, Mundo!</span>
Would become:
Look carefully at those two lines. That's right. There are identical. Petal lets you access hashes and objects in an entirely transparent way.
This high level of polymorphism means that in most cases you can maintain your code, swap hashes for objects, and not change a single line of your template code.
Now let's say that your method some_object() can take an optional argument so that $my_var-hello_world ('Jack')> returns Hello Jack.
$my_var-
You would write:
<span tal:replace="my_var/hello_world 'Jack'">Hola, Mundo!</span>
Optionally, you can get rid of the quotes by using two dashes, a la GNU command-line option:
<span tal:replace="my_var/hello_world --Jack">Hola, Mundo!</span>
So you can pass parameters to methods using double dashes or quotes. Now let us say that your my_var object also has a method current_user() that returns the current user real name. You can do:
<span tal:replace="my_var/hello_world my_var/current_user">Hola, Mundo!</span>
TRAP:
You cannot write nested expressions such as:
${my_var/hello_world ${my_var/current_user}}
This will NOT work. At least, not yet.
Let's say that you have a directory called hello_world with the following files:
hello_world
hello_world/en.xhtml hello_world/fr.xhtml hello_world/es.xhtml
You can use Petal as follows in your Perl code:
use Petal; local $Petal::OUTPUT = 'XHTML'; my $template = new Petal ( file => 'hello_world', lang => 'fr-CA' ); print $template->process ( my_var => my_var() );
What will happen is that the $template object will try to find a file named fr-CA, then fr, then will default to <en>. It should work fine for includes, too!
$template
fr-CA
fr
TIP:
If you feel that 'en' should not be the default language, you can specify a different default:
my $template = new Petal ( file => 'hello_world', language => 'zh', default_language => 'fr' # vive la France! );
If you do specify the lang option, you MUST use a path to a template directory, not a file directory.
lang
Conversely, if you do not specify a lang option, you MUST use a path to a template file, not a directory.
When you create a Petal template object you can specify various options using name => value pairs as arguments to the constructor. For example:
my $template = Petal->new( file => 'gerbils.html', base_dir => '/var/www/petshop', input => 'HTML', output => 'HTML', );
The recognized options are:
The template filename. This option is mandatory and has no default.
Note: If you also use 'language' this option should point to a directory.
The directories listed in this option will be searched in turn to locate the template file. A single directory can be specified as a scalar. For a directory list use an arrayref.
Defines the format of the template files. Recognised values are:
'HTML' - Petal will use HTML::TreeBuilder to parse the template 'XHTML' - Alias for 'HTML' 'XML' - Petal will use XML::Parser to parse the template
Defines the format of the data generated as a result of processing the template files. Recognised values are:
'HTML' - Petal will output XHTML, self-closing certain tags 'XHTML' - Alias for 'HTML' 'XML' - Petal will output generic XML
For internationalized applications, you can use the 'file' option to point to a directory and select a language-specific template within that directory using the 'language' option. Languages are selected using a two letter code (eg: 'fr') optionally followed by a hyphen and a two letter country code (eg: 'fr-CA').
This language code will be used if no template matches the selected language-country or language.
If set to true, makes perl taint mode happy.
true
If set to true, Petal will confess() errors when trying to access undefined template variables, otherwise an empty string will be returned.
If set to false, Petal will not use the Petal::Cache::Disk module.
false
Petal::Cache::Disk
If set to false, Petal will not use the Petal::Cache::Memory module.
Petal::Cache::Memory
The maximum number of recursive includes before Petal stops processing. This is to guard against accidental infinite recursions.
If this option is true, when Petal cannot process a template it will output lots of debugging information in a temporary file which you can inspect.
This option will work only if you use Perl 5.8.
If specified, Petal will assume encode the output in the character set charset. Please note that the utf-8 flag will be ALWAYS turned off, even if you specify utf8.
charset can be any character set that can be used with the module Encode.
If specified, Petal will assume that the template to be processed (and its sub-templates) are in the character set charset.
If you want to use an option throughout your entire program and don't want to have to pass it to the constructor each time, you can set them globally. They will then act as defaults unless you override them in the constructor.
$Petal::BASE_DIR (use base_dir option) $Petal::INPUT (use input option) $Petal::OUTPUT (use output option) $Petal::TAINT (use taint option) $Petal::ERROR_ON_UNDEF_VAR (use error_on_undef_var option) $Petal::DISK_CACHE (use disk_cache option) $Petal::MEMORY_CACHE (use memory_cache option) $Petal::MAX_INCLUDES (use max_includes option) $Petal::LANGUAGE (use default_language option) $Petal::DEBUG_DUMP (use debug_dump option) $Petal::ENCODE_CHARSET (use encode_charset option) $Petal::DECODE_CHARSET (use decode_charset option)
This functionality is directly and shamelessly stolen from the excellent TAL specification: http://www.zope.org/Wikis/DevSite/Projects/ZPT/TAL.
Abstract
<tag tal:define="variable_name EXPRESSION">
Evaluates EXPRESSION and assigns the returned value to variable_name.
EXPRESSION
variable_name
Example
<!--? sets document/title to 'title' --> <span tal:define="title document/title">
Why?
This can be useful if you have a very/very/long/expression. You can set it to let's say vvle and then use vvle instead of using very/very/long/expression.
very/very/long/expression
vvle
<tag tal:condition="true:EXPRESSION"> blah blah blah </tag>
<span tal:condition="true:user/is_authenticated"> Yo, authenticated! </span>
Conditions can be used to display something if an expression is true. They can also be used to check that a list exists before attempting to loop through it.
<tag tal:repeat="element_name EXPRESSION"> blah blah blah </tag>
Example:
<li tal:repeat="user system/user_list">$user/real_name</li>
Repeat statements are used to loop through a list of values, typically to display the resulting records of a database query.
<tag tal:attributes="attr1 EXPRESSION_1; attr2 EXPRESSION_2"; ..."> blah blah blah </tag>
<a href="http://www.gianthard.com" lang="en-gb" tal:attributes="href document/href_relative; lang document/lang">
Attributes statements can be used to template a tag's attributes.
<tag tal:content="EXPRESSION">Dummy Data To Replace With EXPRESSION</tag>
By default, the characters greater than, lesser than, double quote and ampersand are encoded to the entities <, >, " and & respectively. If you don't want them to (because the result of your expression is already encoded) you have to use the structure keyword.
structure
<span tal:content="title">Dummy Title</span> <span tal:content="structure some/variable"> blah blah blah </span>
It lets you replace the contents of a tag with whatever value the evaluation of EXPRESSION returned. This is handy because you can fill your templates with dummy content which will make them usable in a WYSIWYG tool.
<tag tal:replace="EXPRESSION"> This time the entire tag is replaced rather than just the content! </tag>
<span tal:replace="title">Dummy Title</span>
Similar reasons to content. Note however that tal:content and tal:replace are *NOT* aliases. The former will replace the contents of the tag, while the latter will replace the whole tag.
content
tal:content
tal:replace
Indeed you cannot use tal:content and tal:replace in the same tag.
<tag tal:omit-tag="EXPRESSION">Some contents</tag>
<b tal:omit-tag="not:bold">I may not be bold.</b>
If not:bold is evaluated as TRUE, then the <b> tag will be omited. If not:bold is evaluated as FALSE, then the <b> tag will stay in place.
not:bold
omit-tag statements can be used to leave the contents of a tag in place while omitting the surrounding start and end tags if the expression which is evaluated is TRUE.
If you want to ALWAYS remove a tag, you can use omit-tag="string:1"
omit-tag="string:1"
<tag on-error="EXPRESSION">...</tag>
<p on-error="string:Cannot access object/method!!"> $object/method </p>
When Petal encounters an error, it usually dies with some obscure error message. The on-error statement lets you trap the error and replace it with a proper error message.
on-error
You can do things like:
<p tal:define="children document/children" tal:condition="children" tal:repeat="child children" tal:attributes="lang child/lang; xml:lang child/lang" tal:content="child/data" tal:on-error="string:Ouch!">Some Dummy Content</p>
Given the fact that XML attributes are not ordered, withing the same tag statements will be executed in the following order:
define condition repeat attributes content OR replace OR omit-tag content
On top of all that, for people who are lazy at typing the following aliases are provided (although I would recommend sticking to the defaults):
* tal:define - tal:def, tal:set * tal:condition - tal:if * tal:repeat - tal:for, tal:loop, tal:foreach * tal:attributes - tal:att, tal:attr, tal:atts * tal:content - tal:inner * tal:replace - tal:outer
Don't forget that the default prefix is petal: NOT tal:, until you set the petal namespace in your HTML or XML document as follows:
<html xmlns:tal="http://purl.org/petal/1.0/">
Let's say that your base directory is /templates, and you're editing /templates/hello/index.html.
/templates
/templates/hello/index.html
From there you want to include /templates/includes/header.html
/templates/includes/header.html
You can use a subset of the XInclude syntax as follows:
<body xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="/includes/header.html" /> </body>
For backwards compatibility reasons, you can omit the first slash, i.e.
<xi:include href="includes/header.html" />
If you'd rather use a path which is relative to the template itself rather than the base directory, you can do it but the path MUST start with a dot, i.e.
<xi:include href="../includes/header.html" /> <xi:include href="./subdirectory/foo.xml" />
etc.
The href parameter does not support URIs, no other tag than xi:include is supported, and no other directive than the href parameter is supported at the moment.
href
xi:include
Also note that contrarily to the XInclude specification Petal DOES allow recursive includes up to $Petal::MAX_INCLUDES. This behavior is very useful when templating structures which fit well recursive processing such as trees, nested lists, etc.
$Petal::MAX_INCLUDES
You can ONLY use the following Petal directives with Xinclude tags:
* on-error * define * condition * repeat
replace, content, omit-tag and attributes are NOT supported in conjunction with XIncludes.
replace
omit-tag
attributes
Petal now supports a subset of the METAL specification, which is a very WYSIWYG compatible way of doing includes. The current implementation supports only two metal statements: define-macro and use-macro.
In order to define a macro inside a file (i.e. a fragment to be included), you use the metal:use-macro directive. For example:
File foo.xml ============ <html> <body> <p metal:define-macro="footer"> (c) Me (r)(tm) (pouet pouet) </p> </body> </html>
In order to use a previously defined macro, you use the metal:define-macro directive. For example:
File bar.xml ============ <html> <body> ... plenty of content ... <p metal:use-macro="foo.xml#footer"> Page Footer. </p> </body> </html>
In Zope, METAL macros are expanded first, and then the TAL instructions are processed. However with Petal, METAL macros are expanded at run-time just like regular includes, which allows for recursive macros.
This example templates a sitemap, which on a hierarchically organized site would be recursive by nature:
<html> <body> <p>Sitemap:</p> <li metal:define-macro="recurse"> <a href="#" petal:attributes="href child/Full_Path" petal:content="child/Title" >Child Document Title</a> <ul petal:define="children child/Children" petal:condition="children" petal:repeat="child children" > <li metal:use-macro="#recurse">Dummy Child 1</li> <li petal:replace="nothing">Dummy Child 2</li> <li petal:replace="nothing">Dummy Child 3</li> </ul> </li> </body> </html>
Petal has the ability to bind template variables to the following Perl datatypes: scalars, lists, hash, arrays and objects. The article describes the syntax which is used to access these from Petal templates.
In the following examples, we'll assume that the template is used as follows:
my $hashref = some_complex_data_structure(); my $template = new Petal ('foo.xml'); print $template->process ( $hashref );
Then we will show how the Petal Expression Syntax maps to the Perl way of accessing these values.
Perl expression
$hashref->{'some_value'};
Petal expression
some_value
<!--? Replaces Hello, World with the contents of $hashref->{'some_value'} --> <span tal:replace="some_value">Hello, World</span>
$hashref->{'some_hash'}->{'a_key'};
some_hash/a_key
<!--? Replaces Hello, World with the contents of $hashref->{'some_hash'}->{'a_key'} --> <span tal:replace="some_hash/a_key">Hello, World</span>
$hashref->{'some_array'}->[12]
some_array/12
<!--? Replaces Hello, World with the contents of $hashref->{'some_array'}->[12] --> <span tal:replace="some_array/12">Hello, World</span>
Note: You're more likely to want to loop through arrays:
<!--? Loops trough the array and displays each values --> <ul tal:condition="some_array"> <li tal:repeat="value some_array" tal:content="value">Hello, World</li> </ul>
Perl expressions
1. $hashref->{'some_object'}->some_method(); 2. $hashref->{'some_object'}->some_method ('foo', 'bar'); 3. $hashref->{'some_object'}->some_method ($hashref->{'some_variable'})
Petal expressions
1. some_object/some_method 2a. some_object/some_method 'foo' 'bar' 2b. some_object/some_method "foo" "bar" 2c. some_object/some_method --foo --bar 3. some_object/some_method some_variable
Note that the syntax as described in 2c works only if you use strings which do not contain spaces.
<p> <span tal:replace="value1">2</span> times <span tal:replace="value2">2</span> equals <span tal:replace="math_object/multiply value1 value2">4</span> </p>
Petal lets you traverse any data structure, i.e.
$hashref->{'some_object'} ->some_method() ->{'key2'} ->some_other_method ( 'foo', $hash->{bar} );
some_object/some_method/key2/some_other_method --foo bar
If EXPRESSION returns an array reference If this array reference has at least one element Returns TRUE Else Returns FALSE Else If EXPRESSION returns a TRUE value (according to Perl 'trueness') Returns TRUE Else Returns FALSE
the true: modifiers should always be used when doing Petal conditions.
true:
I'm pretty sure you can work this one out by yourself :-)
Sets the value returned by the evaluation of EXPRESSION in $hash-{variable_name}>. For instance:
$hash-
Perl expression:
$hash->{variable_name} = $hash->{object}->method();
Petal expression:
set:variable_name object/method
The string: modifier lets you interpolate petal expressions within a string and returns the value.
string:
string:Welcome $user/real_name, it is $date!
Alternatively, you could write:
string:Welcome ${user/real_name}, it is ${date}!
The advantage of using curly brackets is that it lets you interpolate expressions which invoke methods with parameters, i.e.
string:The current CGI 'action' param is: ${cgi/param --action}
For certain things which are not doable using TAL you can use what I call the UGLY SYNTAX. The UGLY SYNTAX is UGLY, but it can be handy in some cases.
For example consider that you have a list of strings:
$my_var = [ 'Foo', 'Bar', 'Baz' ]; $template->process (my_var => $my_var, buz => $buz);
And you want to display:
<title>Hello : Foo : Bar : Baz</title>
Which is not doable with TAL without making the XHTML invalid. With the UGLY SYNTAX you can do:
<title>Hello<?for name="string my_var"?> : <?var name="string"?><?end?></title>
Of course you can freely mix the UGLY SYNTAX with other Petal syntaxes. So:
<title><?for name="string my_var"?> $string <?end?></title>
Mind you, if you've managed to read the doc this far I must confess that writing:
<h1>$string</h1>
instead of:
<h1 tal:replace="string">Dummy</h1>
is UGLY too. I would recommend to stick with TAL wherever you can. But let's not disgress too much.
<?var name="EXPRESSION"?>
<title><?var name="document/title"?></title>
Because if you don't have things which are replaced by real values in your template, it's probably a static page, not a template... :)
Usual stuff:
<?if name="user/is_birthay"?> Happy Birthday, $user/real_name! <?else?> What?! It's not your birthday? A very merry unbirthday to you! <?end?>
You can use condition instead of if, and indeed you can use modifiers:
condition
if
<?condition name="false:user/is_birthay"?> What?! It's not your birthday? A very merry unbirthday to you! <?else?> Happy Birthday, $user/real_name! <?end?>
Not much else to say!
Use either for, foreach, loop or repeat. They're all the same thing, which one you use is a matter of taste. Again no surprise:
for
foreach
loop
repeat
<h1>Listing of user logins</h1> <ul> <?repeat name="user system/list_users"?> <li><?var name="user/login"?> : <?var name="user/real_name"?></li> <?end?> </ul>
Variables are scoped inside loops so you don't risk to erase an existing user variable which would be outside the loop. The template engine also provides the following variables for you inside the loop:
user
<?repeat name="foo bar"?> <?var name="repeat/index"?> - iteration number, starting at 0 <?var name="repeat/number"?> - iteration number, starting at 1 <?var name="repeat/start"?> - is it the first iteration? <?var name="repeat/end"?> - is it the last iteration? <?var name="repeat/inner"?> - is it not the first and not the last iteration? <?var name="repeat/even"?> - is the count even? <?var name="repeat/odd"?> - is the count odd? <?end?>
Again these variables are scoped, you can safely nest loops, ifs etc... as much as you like and everything should be fine.
The XInclude syntax should be preferred over this...
<?include file="include.xml"?>
It will include the file 'include.xml', using the current @Petal::BASE_DIR directory list.
@Petal::BASE_DIR
If you want use XML::Parser to include files, you should make sure that the included files are valid XML themselves... FYI XML::Parser chokes on this:
<p>foo</p> <p>bar</p>
But this works:
<div> <p>foo</p> <p>bar</p> </div>
(Having only one top element is part of the XML spec).
Petal lets you write your own modifiers, either using coderefs or modules.
Let's say that you want to write an uppercase: modifier, which would uppercase the result of an expression evaluation, as in:
uppercase:string:Hello, World
Would return
HELLO, WORLD
Here is what you can do:
# don't forget the trailing colon in C<uppercase:> !! $Petal::Hash::MODIFIERS->{'uppercase:'} = sub { my $hash = shift; my $args = shift; my $result = $hash->fetch ($args); return uc ($result); };
You might want to use a module rather than a coderef. Here is the example above reimplemented as a module:
package Petal::Hash::UpperCase; use strict; use warnings; sub process { my $class = shift; my $hash = shift; my $args = shift; my $result = $hash->fetch ($args); return uc ($result); } 1;
As long as your module is in the namespace Petal::Hash::<YourModifierName>, Petal will automatically pick it up and assign it to its lowercased name, i.e. in our example uppercase:.
uppercase:
If your modifier is OUTSIDE Petal::Hash::<YourModifierName>, you need to make Petal aware of its existence as follows:
use MyPetalModifier::UpperCase; $Petal::Hash::MODIFIERS->{'uppercase:'} = 'MyPetalModifier::UpperCase';
By default Petal will encode &, <, > and " to &, <, > and " respectively. However sometimes you might want to display an expression which is already encoded, in which case you can use the structure keyword.
&
<
"
&
<
>
"
structure my/encoded/variable
Note that this is a language keyword, not a modifier. It does not use a trailing colon.
Petal caches the expressions which it resolves, i.e. if you write the expression:
string:$foo/bar, ${baz/buz/blah}
Petal::Hash will compute it once, and then for subsequent accesses to that expression always return the same value. This is almost never a problem, even for loops because a new Petal::Hash object is used for each iteration in order to support proper scoping.
However, in some rare cases you might not want to have that behavior, in which case you need to prefix your expression with the fresh keyword, i.e.
fresh
fresh string:$foo/bar, ${baz/buz/blah}
You can use fresh with structure if you need to:
fresh structure string:$foo/bar, ${baz/buz/blah}
However the reverse does not work:
<!--? VERY BAD, WON'T WORK !!! --> structure fresh string:$foo/bar, ${baz/buz/blah}
Displays the canonical template for template.xml. You can set $Petal::INPUT using by setting the PETAL_INPUT environment variable. You can set $Petal::OUTPUT using by setting the PETAL_OUTPUT environment variable.
$Petal::INPUT
$Petal::OUTPUT
Displays the perl code for template.xml. You can set $Petal::INPUT using by setting the PETAL_INPUT environment variable. You can set $Petal::OUTPUT using by setting the PETAL_OUTPUT environment variable.
Displays the perl code for template.xml, with line numbers. You can set $Petal::INPUT using by setting the PETAL_INPUT environment variable. You can set $Petal::OUTPUT using by setting the PETAL_OUTPUT environment variable.
The cycle of a Petal template is the following:
1. Read the source XML template 2. $INPUT (XML or HTML) throws XML events from the source file 3. $OUTPUT (XML or HTML) uses these XML events to canonicalize the template 4. Petal::CodeGenerator turns the canonical template into Perl code 5. Petal::Cache::Disk caches the Perl code on disk 6. Petal turns the perl code into a subroutine 7. Petal::Cache::Memory caches the subroutine in memory 8. Petal executes the subroutine
If you are under a persistent environement a la mod_perl, subsequent calls to the same template will be reduced to step 8 until the source template changes.
Otherwise, subsequent calls will resume at step 6, until the source template changes.
Petal was not able to import one of the modules. This error warning will be issued when Petal is unable to load a plugin because it has been badly install or is just broken.
You don't need to use encode:EXPRESSION to XML-encode expression anymore, Petal does it for you. encode: has been turned into a no-op.
You tried to invoke an/expression/like/this/one but Petal could not resolve it. This could be because an/expression/like evaluated to undef and hence the remaining this/one could not be resolved.
Usually Petal gives you a line number and a dump of your template as Perl code. You can look at the perl code to try to determine the faulty bit in your template.
Petal was trying to parse a file that is not well-formed XML or that has strange entities in it. Try to run xmllint on your file to see if it's well formed or try to use the $Petal::INPUT = 'XHTML' option.
Either I've forgot to document it, or it's a bug. Send an email to the Petal mailing list or at mailto://jhiver@mkdoc.com.
None.
The XML::Parser wrapper only cannot expand entities <, >, & and ". Besides, I can't get it to NOT expand entities in 'Stream' mode.
>
HTML::TreeBuilder expands all entities, hence s are lost / converted to whitespaces.
XML::Parser is deprecated and should be replaced by SAX handlers at some point.
Copyright 2003 - MKDoc Holdings Ltd.
Authors: Jean-Michel Hiver <jhiver@mkdoc.com>, Fergal Daly <fergal@esatclear.ie>, and others.
This module free software and is distributed under the same license as Perl itself. Use it at your own risk.
Thanks to everybody on the list who contributed to Petal in the form of patches, bug reports and suggestions. See README for a list of contributors.
Join the Petal mailing list:
http://lists.webarch.co.uk/mailman/listinfo/petal
Mailing list archives:
http://lists.webarch.co.uk/pipermail/petal
Have a peek at the TAL / TALES / METAL specs:
http://www.zope.org/Wikis/DevSite/Projects/ZPT/TAL http://www.zope.org/Wikis/DevSite/Projects/ZPT/TALES http://www.zope.org/Wikis/DevSite/Projects/ZPT/METAL
Any extra questions? jhiver@mkdoc.com.
To install Petal, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Petal
CPAN shell
perl -MCPAN -e shell install Petal
For more information on module installation, please visit the detailed CPAN module installation guide.