Free templates software for linux

Label Templates are free Opendocument Format label templates for Openoffice.org, KOffice or any other Office suite ODF ready for making labels.

Collection includes CD, DVD, address, mailing, round, media label templates, Avery sizes and more. US Letter size and 14 size paper formats available.

Setup time is quick with these templates and printing labels from these templates is easy.

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.

Template Lite is a smaller, faster alternative to the Smarty template engine.
For the most part, it is a drop in replacement for Smarty but uses around half of the memory and is considerably faster and far less CPU intensive when compiling and displaying templates.
Template lite was originally created by Paul Lockaby as a smaller replacement for Smarty. The original package was called Smarty Light. Even though Smarty is an Open Source project the creators of Smarty decided to trademark the name Smarty. Because of this trademarking of the name they contacted Paul Lockaby and told him he could nolonger use Smarty in the name for the package.
Paul Lockaby gave me permission to fork the project if I wanted as he was closing down support and developement for Smarty Light. The initial release of Template Lite contains a few minor bug fixes and some extra features.
I plan on adding more features to Template Lite over the next few months. For the most part Template Lite is a drop in replacement for Smarty. The nice thing about this package is how it uses around half of the memory of Smarty and it is considerably FASTER and far less CPU intensive when compiling and displaying templates.
Enhancements:
- register_resource and unregister_resource support was added.
- Different resources are supported by everything except for cached template output.
- The _get_resource internal function was added for processing "file:" and absolute tag resources.
- The resize_image plugin was added.
- Support for absolute paths to template files was fixed.

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.

Template::Plugins is a Perl module with plugin provider.

SYNOPSIS

use Template::Plugins;

$plugin_provider = Template::Plugins->new(%options);

($plugin, $error) = $plugin_provider->fetch($name, @args);

The Template::Plugins module defines a provider class which can be used to load and instantiate Template Toolkit plugin modules.

Template::Magic is a Perl module for magic merger of runtime values with templates.

SYNOPSIS

Just add these 2 magic lines to your code...

use Template::Magic;
Template::Magic->new->print( /path/to/template );

to have all your variable and subroutines merged with the template file, or set one or more constructor array to customize the output generation as you need:

use Template::Magic qw( -compile );

$tm = new Template::Magic
paths => [ qw(/any/path /any/other/path) ] ,
markers => [ qw( < / > ) ] ,
lookups => [ %my_hash, $my_obj, main ] ,
zone_handlers => [ &my_zone_handler, _EVAL_ ] ,
value_handlers => [ DEFAULT, &my_value_handler ] ,
text_handlers => sub {print lc $_[1]} ,
output_handlers => sub {print uc $_[1]} ,
post_handlers => &my_post_handler ,
options => no_cache ;

$tm->nprint( template => /path/to/template
lookups => %my_special_hash );

Template::Alloy is a TT2/3, HT, HTE, Tmpl, and Velocity Engine.

SYNOPSIS

Template::Toolkit style usage
my $t = Template::Alloy->new(
INCLUDE_PATH => [/path/to/templates],
);

my $swap = {
key1 => val1,
key2 => val2,
code => sub { 42 },
hash => {a => b},
};

# print to STDOUT
$t->process(my/template.tt, $swap)
|| die $t->error;

# process into a variable
my $out = ;
$t->process(my/template.tt, $swap, $out);

### Alloy uses the same syntax and configuration as Template::Toolkit
HTML::Template::Expr style usage
my $t = Template::Alloy->new(
filename => my/template.ht,
path => [/path/to/templates],
);

my $swap = {
key1 => val1,
key2 => val2,
code => sub { 42 },
hash => {a => b},
};

$t->param($swap);

# print to STDOUT (errors die)
$t->output(print_to => *STDOUT);

# process into a variable
my $out = $t->output;

### Alloy can also use the same syntax and configuration as HTML::Template
Text::Tmpl style usage
my $t = Template::Alloy->new;

my $swap = {
key1 => val1,
key2 => val2,
code => sub { 42 },
hash => {a => b},
};

$t->set_delimiters(#[, ]#);
$t->set_strip(0);
$t->set_values($swap);
$t->set_dir(/path/to/templates);

my $out = $t->parse_file(my/template.tmpl);

my $str = "Foo #[echo $key1]# Bar";
my $out = $t->parse_string($str);


### Alloy uses the same syntax and configuration as Text::Tmpl
Velocity (VTL) style usage
my $t = Template::Alloy->new;

my $swap = {
key1 => val1,
key2 => val2,
code => sub { 42 },
hash => {a => b},
};

my $out = $t->merge(my/template.vtl, $swap);

my $str = "#set($foo 1 + 3) ($foo) ($bar) ($!baz)";
my $out = $t->merge($str, $swap);