Free approval workflow template software for linux

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.

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=~/

Workflow::Factory is a Perl module that generates new workflow and supporting objects.

SYNOPSIS

# Import the singleton for easy access
use Workflow::Factory qw( FACTORY );

# Add XML configurations to the factory
FACTORY->add_config_from_file( workflow => workflow.xml,
action => [ myactions.xml, otheractions.xml ],
validator => [ validator.xml, myvalidators.xml ],
condition => condition.xml,
persister => persister.xml );

# Create a new workflow of type MyWorkflow
my $wf = FACTORY->create_workflow( MyWorkflow );

# Fetch an existing workflow with ID 25
my $wf = FACTORY->fetch_workflow( MyWorkflow, 25 );

Public

The Workflow Factory is your primary interface to the workflow system. You give it the configuration files and/or data structures for the Workflow, Workflow::Action, Workflow::Condition, Workflow::Persister, and Workflow::Validator objects and then you ask it for new and existing Workflow objects.

Internal

Developers using the workflow system should be familiar with how the factory processes configurations and how it makes the various components of the system are instantiated and stored in the factory.

HTML::Template module attempts to make using HTML templates simple and natural.
HTML::Template library extends standard HTML with a few new tags for variables, loops, if/else blocks and includes.
A file written with HTML and these new tags is called a template. Using this module you fill in the values for the variables and loops declared in the template.
This allows you to seperate design (the HTML) from the data, which you generate in the Perl script. While there are many other HTML template systems available, this module is simple and fast.
It doesnt try to reinvent Perl CGI, it just augments HTML with a few new and very useful abilities.
Enhancements:
- A new option was added to enforce Taint mode for unescaped variables.
- Several long-standing bugs were fixed.
- The enhanced tests produced by the Phalanx project are now part of the module.

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

The MfGames.Template library is a C# native library for creating template libaries.

MfGames.Template was inspired by NVelocity, but was designed from the ground up to use the CIL internals, such as System.CodeDom and internal compliation to handle the template language.

Because of this, it supports C# code as the template "language". In addition, compiled templates are actually compiled down into bytecode, using the built-in compiler.

Class::MakeMethods::Template package contains extensible code templates.

SYNOPSIS

package MyObject;
use Class::MakeMethods::Template::Hash (
new => new,
string => foo,
number => bar,
);

my $obj = MyObject->new( foo => "Foozle", bar => 23 );
print $obj->foo();
$obj->bar(42);

MOTIVATION

If you compare the source code of some of the closure-generating methods provided by other subclasses of Class::MakeMethods, such as the hash accessors provided by the various Standard::* subclasses, you will notice a fair amount of duplication. This module provides a way of assembling common pieces of code to facilitate support the maintenance of much larger libraries of generated methods.

This module extends the Class::MakeMethods framework by providing an abstract superclass for extensible code-templating method generators.
Common types of methods are generalized into template definitions. For example, Template::Generics new provides a template for methods that create object instances, while Template::Generics scalar is a template for methods that allow you to get and set individual scalar values.

Thse definitions are then re-used and modified by various template subclasses. For example, the Template::Hash subclass supports blessed-hash objects, while the Template::Global subclass supports shared data; each of them includes an appropriate version of the scalar accessor template for those object types.

Each template defines one or more behaviors, individual methods which can be installed in a calling package, and interfaces, which select from those behaviours and indicate the names to install the methods under.

Each individual meta-method defined by a calling package requires a method name, and may optionally include other key-value parameters, which can control the operation of some meta-methods.