Free fast template software for linux

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.

MAT Template Library is a C++ mathematical template class library. The library contains classes and routines for working with:

matrices
vectors
finding roots of polynomials
solving equations
and more...

kmail templates is a patch for current 3.5 branch of kdepim package which replaces Phrases configuration with more rich templates engine.

Templates use template syntax of well-known Thebat! mail client and allow construct a little more complicated messages than now.

Template::Ast is a Perl module to process ASTs for Perl Template Toolkit.

SYNOPSIS

use Template::Ast;

# Rebuild AST stored in file:
$ast = Template::Ast->read(foo.ast) or
die Template::Ast->error();

# Writing existing AST to file:
$ast = { Marry => [24, F], John => [21, M] };
Template::Ast->write($ast, foo.ast) or
die Template::Ast->error();

$ast = Template::Ast->merge([1,2,3], undef); # [1,2,3]
$ast = Template::Ast->merge(undef, [1,2,3]); # [1,2,3]
$ast = Template::Ast->merge(undef, undef); # undef

$ast = Template::Ast->merge({A=>1,B=>2}, [C]); # [C]
$ast = Template::Ast->merge([1,2,3], [5,6]); # [5,6]
$ast = Template::Ast->merge([{A=>1},2], 5); # 5

$ast = Template::Ast->merge({A=>1,B=>2}, {C=>3}); # {A=>1,B=>2,C=>3}
$ast = Template::Ast->merge({A=>1,B=>2}, {B=>3}); # {A=>1,B=>3}

# {A=>1,B=>2}
$ast = Template::Ast->merge({A=>1,B=>undef}, {A=>undef,B=>2});

Template::Ast->merge(
{A=>1,B=>{C=>1,D=>2}},
{B=>{C=>1,D=>3,E=>4}}
); # {A=>1,B=>{C=>1,D=>3,E=>4}}

Template::Ast->merge(
{A=>1,B=>{C=>[1,2]}},
{B=>{C=>[3,4]}}
); # {A=>1,B=>{C=>[3,4]}}

print Template::Ast->dump([$vars], [vars]);

ASTs are essential in the programming model based on Perl Template Toolkit. This module provides some easy interface to do the dirty work involved in AST handling. The term AST used here are referred to any Perl referece pointed to a complex data structure, such as a nested hash, a nested array, or such.

Pod::Template is a Perl module for building pod documentation from templates.

SYNOPSIS

### As a module ###
use Pod::Template;
my $parser = new Pod::Template;
$parser->parse( template => documentation.ptmpl );

print $parser->as_string


### As a script ###
$ podtmpl -I dir1 -I dir2 documentation.ptmpl


### A simple module prepared to use Pod::Template ###
package My::Module;

=Template print_me
=head2 print_me( $string )

Prints out its argument.

=cut

sub print_me { print shift; return 1 }


### A simple pod file named Extra/Additional.pod ###
=pod
=Template return_vals

This subroutine returns 1 for success and undef for failure.

=cut


### A simple Pod::Template template ###
=Include My::Module
=Include Extra/Additional.pod as Extra

=pod

=head1 SYNOPSIS

use My::Module

My::Module::print_me(some text);

=head2 Functions

=Insert My::Module->print_me

=Insert Extra->return_vals

=cut

Writing documentation on a project maintained by several people which spans more than one module is a tricky matter. There are many things to consider:

Location
Should pod be inline (above every function), at the bottom of the module, or in a distinct file? The first is easier for the developers, but the latter two are better for the pod maintainers.

Order
What order should the documentation be in? Does it belong in the order in which the functions are written, or ordered by another principle, such as frequency of use or function type? Again, the first option is better for the developers, while the second two are better for the user.

References
How should a function in another file be mentioned? Should the documentation simply say see Other::Module, or should it include the relevant section? Duplication means that the documentation is more likely to be outdated, but its bad for a user to have to read numerous documents to simply find out what an inherited method does.

Headers & Footers
What should be done with standard headers and footers? Should they be pasted in to every file, or can the main file be assumed to cover the entire project?

Pod::Template offers a solution to these problems: documentation is built up from templates.

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.