HTML::CMTemplate.pm is a Perl module that can generate text-based content from templates.

SYNOPSIS
use HTML::CMTemplate;

$t = new HTML::CMTemplate( path => [ /path1, /longer/path2 ] );

$t->import_template(
filename => file.html.ctpl, # in the paths above
packagename => theTemplate,
importrefs => { myvar => hello },
importclean => { myclean => clean! },
);

theTemplate::cleanup_namespace();

print "Content-type: text/htmlnn";
print theTemplate::output();

# Template syntax is described below -- see that section to get the real
# details on how to use this sucker.

HTML::CMTemplate 0.4.0

A class for generating text-based content from a simple template language. It was inspired by the (as far as Im concerned, incomplete) HTML::Template module, and was designed to make template output extremely fast by converting a text/html template into a dynamic perl module and then running code from that module. Since the parsing happens only once and the template is converted into Perl code, the output of the template is very fast.

It was designed to work with mod_perl and FastCGI and has been the basis for all of the dynamic content on the Orangatango site (http://www.orangatango.com).

First release (version 0.1) was February 15, 2001 and was very quiet because it was a proprietary version.

As of version 0.2, it is released under the Artistic License. Its a much more feature-rich version as well as being Open Source! For a copy of the Artistic License, see the files that came with your Perl distribution.

The code was developed during my time at Orangatango. It has been released as open source with the blessing of the controlling entities there.

HTML::Template::JIT is a just-in-time compiler for HTML::Template. Templates are compiled into native machine code using Inline::C.
When using HTML::Template::JIT, the compiled code is stored to disk and reused on subsequent calls. HTML::Template::JIT is up to 8 times as fast as HTML::Template using caching.
Enhancements:
- Fixed param() to allow for blessed hash-refs. [Alex Kapranoff]
- Fixed url-escaping to work with UTF-8 characters. [Alex Kapranoff]
- Added support for JS escaping. [Alex Kapranoff]
- Fixed a compatibility problem with HTML::Template v2.8, which is now a prerequisite.

Blitz templates is a fast template engine written in C and compiled as a PHP module. It started as a php_templates replacement, but developed into much more.
The project is based on extensible template controllers (custom view classes in PHP) and weakly-active templates (simple logic in HTML).
Enhancements:
- Lot of code cleanup was done.
- The "parse" and "include" methods were improved, and their "vars" argument is not a globals array anymore; now its just an arbitrary iteration set and both methods comply with set/block/fetch.
- Templates included by the "include" method from PHP code inherit globals from the caller automatically.
- Corresponding tests were updated.
- A new article was added to the documentation: "Quick Geek Blitz Tutorial", which is addressed to those professionals who want to learn API basics in a minimum of time.

XMLNews::HTMLTemplate is Perl module for converting NITF to HTML.

SYNOPSIS

use XMLNews::HTMLTemplate;

my $template = new XMLNews::HTMLTemplate();
$template->readTemplate("mytemplate.html");

$template->applyTemplate("output.html", "story.xml", "story.rdf");

NOTE: this module requires the XML::Parser and XMLNews::Meta modules.

WARNING: this module is not thread-safe or re-entrant.

The XMLNews::HTMLTemplate module provides a simple mechanism for creating HTML pages from XML/NITF news stories and/or XML/RDF metadata files based on a user-supplied template file. The template is a simple HTML file (SGML or XML flavour) using special template commands, which the user includes as processing instructions, as in the following example:

To create an HTML page, you must first create an empty HTMLTemplate object:

my $template = new XMLNews::HTMLTemplate();

Next, you load the HTML template into the object:

$template->readTemplate("mytemplate.html");

Now, you can apply the same compiled template object repeatedly to different XML/NITF and/or XML/RDF documents to generate HTML pages:

$template->applyTemplate("outfile.html", "newsstory.xml", "newsstory.rdf");

SmartTemplate is a Template Engine that was designed to support large scale, web based applications.
Whats so special about it?
Common template engines work like the following: Your PHP script specifies an HTML template and assigns some dynamic content to display. The template parser replaces all placeholders within the template with the assigned content and displays it to the user. This means a lot of string processing and regular expression work each time you want to display some content.
SmartTemplate works like a template compiler that converts templates into executable PHP code and stores it for later reuse. The first time a new template is processed, all placeholders in the template are replaced by small PHP code elements that print the assigned content. The HTML template fragment < H3 >{TITLE}< /H3 >, for example, is converted into something like < H3 >< ?php echo $TITLE; ? >< /H3 >. If you have assigned your content to the right variables, there is no need for any template parsing anymore. The only thing that has to be done is to include and execute the compiled template. This usually increases the execution time of the template engine dramatically.
SmartTemplate supports:
- Simple Scalar Substitution (Strings, etc.)
- Block Iterations (nested Arrays / BEGIN..END)
- Basic Control Structures (IF..ELSEIF..ELSE)
- Custom Extension (Output filters, uppercase, sprintf, etc.)
- Template Compilation (HTML templates are converted to executable PHP Code)
- SubTemplate System (HTML templates can be included on other templates)
- Output Caching (Accelerates your applications by reusing page output)

HTML::Template::Extension::DOC are plugins for comments in template.

SYNOPSIS

use HTML::Template::Extension;

my $text = qq
|
< HTML >< HEAD >< /HEAD >< BODY >
< H1 >This is a template example...< /H1 >
< TMPL_DOC >An example use of TMPL_DOC tag < /TMPL_DOC >
The sum between 1+1 is: < TMPL_VAR NAME="result" >
< /BODY >< /HTML >
|;

my $comp = new HTML::Template::Extension(
scalarref => $text,
plugins=>["DOC"],
);

$comp->param(result => 1+1);

print $comp->output;

# OUTPUT:
#
# < HTML >< HEAD >< /HEAD >< BODY >
# < H1 >This is a template example...< /H1 >
# The sum between 1+1 is: 2
# < /BODY >< /HTML >

DOC plugin add a < TMPL_DOC >some comments< /TMPL_DOC > to standard HTML::Template syntax to permit to add comments to template that, for indeed, a web graphic designer can view in a WYSIWYG environment.

All text between < TMPL_DOC > and < /TMPL_DOC > and tag itself will be deleted before HTML::Template parsing and retuning template output.