Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Any::Template(3)      User Contributed Perl Documentation     Any::Template(3)

NAME
       Any::Template - provide a consistent interface to a wide	array of
       templating languages

SYNOPSIS
	       use Any::Template;
	       my $template = new Any::Template({
		       Backend => 'HTML::Template',
		       Filename	=> 'page.tmpl',
		       Options => {'strict' => 0}
	       });
	       my $output = $template->process($data);

	       my $template2 = new Any::Template({
		       Backend => 'Text::Template',
		       String => $template2_content
	       });
	       $template->process($data, \*STDOUT);

DESCRIPTION
       This module provides a simple, consistent interface to common
       templating engines so you can write code	that is	agnostic to the
       template	language used in the presentation layer.  This means you can
       allow your interface developers to work in the templating language
       they're happiest	in or write code that works with legacy/in-house
       templating modules but can also be released onto	CPAN and work with
       more standard CPAN templating systems.

       By its very nature, this	interface only exposes pretty much the lowest
       common denominator of the template engine APIs.	It does	however
       provide a fairly	rich set of input and output mechanisms, using native
       implementations where available and providing some default
       implementations to extend the default set offered by some templating
       modules.

       If you need the quirky features of a particular templating engine, then
       this may	not be for you.	 Having	said that, in some cases you may be
       able to encapsulate some	of your	logic in options passed	into the
       adaptor classes (either rolling your own	adaptors, or improving ours)
       to pull the relevant strings on the backend module.

       Templateing languages supported by backends supplied with this
       distribution can	be found in the	README (remember there may be others
       out there and you can always roll your own).

METHODS
       my $template = new Any::Template(\%options);
		   See below for a list	of options

       $template->process($data_structure, $sink);
		   $sink can be:
			   - a scalar ref
			   - a filename	(string)
			   - a filehandle (as a	glob or	glob ref) or an	object offering	a print	method
			   - a coderef (output will be passed in as the	first argument)

       $string = $template->process($data_structure);
	   A convenience form, if no second argument is	passed to "process()",
	   equivalent to:

		   my $string;
		   $template->process($data_structure, \$string);

	   except data is passed by value rather than by reference.

       $templating_engine = $template->native_object();
	   Allows the native templating	engine to be accessed.	This
	   completely breaks the abstraction of	Any::Template so it's not
	   recommended you use it other	than as	a bridging strategy as part of
	   a refectoring/migration process (with a view	to ultimately
	   eliminating its use).

SUBROUTINES
       available_backends
	    $list_of_backends =	Any::Template::available_backends();

	   Scans @INC for a list of modules in the Any::Template::Backend::
	   namespace.

ERROR HANDLING
       If an error occurs, an exception	is raised with die().  You can use an
       eval block to handle the	exception.  $@ will contain an error message.

CONSTRUCTOR OPTIONS
       Backend
	   Backends distributed	with this module are listed in the
	   distribution	README.

	   See Any::Template::Backend for information on writing your own
	   backends.  You should be able to create a new backend in a couple
	   of dozen lines of code and slot it into the unit test with a	one or
	   2 line change.

       Filename
		   Filename of the template file

       String
		   String containing the template

       Filehandle
		   Reference to	a filehandle from which	to read	the template

       Options
		   A hashref of	options	passed to the backend templating engine

ENVIRONMENT
       If you don't supply a Backend to	the constructor, Any::Template looks
       for a default Backend in	the ANY_TEMPLATE_DEFAULT environment variable.
       This allows you to retrofit Any::Template into legacy code without
       hard-coding a default templating	language or forcing a backwardly-
       incompatible change to the interface of the code	you are	retrofitting
       into.

CACHING
       This module doesn't have	built-in caching, however the objects it
       creates are intended to be cachable (where possible the backends	hold
       onto precompiled	templates that can be fed any number of	data
       structures).  It's therefore up to you what caching strategy you	use.
       In the spirit of	"if you	liked this, you	might also like..."  Cache and
       Cache::Cache offer a consistent interface to a number of	different
       caching strategies.

SEE ALSO
       o   CGI::Application::Plugin::AnyTemplate

       o   Text::MicroMason

       o   Template

       o   HTML::Template

       o   Text::Template

VERSION
       $Revision: 1.15 $ on $Date: 2006/04/18 08:32:26 $ by $Author: johna $

AUTHOR
       John Alden <cpan	_at_ bbc _dot_ co _dot_	uk>

COPYRIGHT
       (c) BBC 2005. This program is free software; you	can redistribute it
       and/or modify it	under the GNU GPL.

       See the file COPYING in this distribution, or
       http://www.gnu.org/licenses/gpl.txt

perl v5.32.0			  2006-05-08		      Any::Template(3)

NAME | SYNOPSIS | DESCRIPTION | METHODS | SUBROUTINES | ERROR HANDLING | CONSTRUCTOR OPTIONS | ENVIRONMENT | CACHING | SEE ALSO | VERSION | AUTHOR | COPYRIGHT

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Any::Template&sektion=3&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help