Free perlpoint template tt2 0.02 software for linux

PerlPoint::Template::TT2 is a beta of a PerlPoint template processor for Template Toolkit 2 layouts.

METHODS

new()

Parameters:

class

The class name.

Returns: the new object.

Example:

# start page
$result.="nnnn";

# begin header
$result.="nnnn";

# header contents: this was added to the traditional list of template files
$result.=$me->_processTemplate(join(/, $tdir, $options->{$toc ? header_toc_template : header_template}), $toc ? 1 : $params{page});

# complete header
$result.="nnnn";

# begin body
$result.="nnnn";

# now the body contents: start with top part
$result.=$me->_processTemplate(join(/, $tdir, $options->{$toc ? top_toc_template : top_template}), $toc ? 1 : $params{page});

# add navigation, if necessary
$result.=$me->_processTemplate(join(/, $tdir, $options->{$toc ? nav_toc_template : nav_template}), $toc ? 1 : $params{page})
if exists $options->{$toc ? nav_toc_template : nav_template};

# include data (for TOCs, make sure not to add a standard TOC if the tree applet is used
# - this should be more generic in case users use other methods ...)
$result.=$toc ? $result=~/

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::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.

PerlPoint::Tags is a Perl module that can process PerlPoint tag declarations.

SYNOPSIS

# declare a tag declaration package
package PerlPoint::Tags::New;

# declare base "class"
use base qw(PerlPoint::Tags);

PerlPoint is built a modularized way. The base packages provide parsing and stream processing for all translators into target formats and are therefore intended to be as general as possible. Thats why they not even define tags, because every translator author may wish to provide own tags special to the addressed target projector (or format, respectively). On the other hand, the parser needs to know about tags to recognize them correctly. That is where this module comes in. It serves as a base of tag declaration modules by providing a general import() method to be inherited by them. This method scans the invoking module for certain data structures containing tag declarations and imports these data into a structure in its own namespace. The parser knows about this PerlPoint::Tags collection and makes it the base of its tag handling.

It is recommended to have a "top level" tag declaration module for each PerlPoint translator, so there could be a PerlPoint::Tags::HTML, a PerlPoint::Tags::Latex, PerlPoint::Tags::SDF, a PerlPoint::Tags::XML and so on. (These modules of course may simply invoke lower level declarations.)

Note: We are speaking in terms of "classes" here but of course we are actually only using the mechanism of import() together with inheritance to provide an intuitive and easy to use way of declaration.

As an additional feature, the module provides a method addTagSets() to allow translator users to declare tags additionally.

PerlPoint::Tags::XML is a PerlPoint tag set used by pp2sdf.

SYNOPSIS

# declare tags used by pp2sdf
use PerlPoint::Tags::XML;

This module declares PerlPoint tags used by XML converters. Tag declarations are used by the parser to determine if a used tag is valid, if it needs options, if it needs a body and so on. Please see PerlPoint::Tags for a detailed description of tag declaration.

Every PerlPoint translator willing to handle the tags of this module can declare this by using the module in the scope where it built the parser object.

# declare basic tags
use PerlPoint::Tags::XML;

# load parser module
use PerlPoint::Parser;

...

# build parser
my $parser=new PerlPoint::Parser(...);

...

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.

PerlPoint::Tags::SDF is a PerlPoint tag set used by pp2sdf.

SYNOPSIS

# declare tags used by pp2sdf
use PerlPoint::Tags::SDF;

This module declares PerlPoint tags used by pp2sdf. Tag declarations are used by the parser to determine if a used tag is valid, if it needs options, if it needs a body and so on. Please see PerlPoint::Tags for a detailed description of tag declaration.

Every PerlPoint translator willing to handle the tags of this module can declare this by using the module in the scope where it built the parser object.

# declare basic tags
use PerlPoint::Tags::SDF;

# load parser module
use PerlPoint::Parser;

...

# build parser
my $parser=new PerlPoint::Parser(...);

...

TAGS

PerlPoint::Tags::SDF declares all the tags of PerlPoint::Tags::Basic.

Additionally, the PerlPoint::Tags::HTML tags L, PAGEREF, SECTIONREF, U and XREF tags are supported. pp2sdf might interprete them slightly different to pp2html, please read its documentation for details.

web.template is a template framework for PHP 5 that uses an XML-based language.
It allows you to create classes with getters that are made accessible to the framework with an addVarClass method.
web.template also supports modifiers, tags, and resource drivers for template or cache storage.
Class Constant Summary
VAR_CLASS_OBJECT = 1
VAR_CLASS_PATH = 2
Variable Summary
array $arrModifiers
array $arrTemplatesResource
array $arrVarClasses
array $arrVariables
boolean $blnCaching
boolean $blnNewLineInCTemplates
IWTResource $objCacheResource
ITemplateCompiler $objCompiler
string $strCacheDir
string $strCompileDir
string $strCustomTagsDir
string $strDefaultResourceProtocol
string $strFilePartSeparator
string $strIDSeparator
string $strLanguage
string $strModifiersDir
string $strTemplateDir
Enhancements:
- This release fixes some small bugs in the fetch() method and in parsing HTML tag parameters.