1HTML::Template::PerlIntUesrefracCeo(n3t)ributed Perl DocHuTmMeLn:t:aTteimopnlate::PerlInterface(3)
2
6 HTML::Template::PerlInterface - perl interface of HTML::Template::Pro
7
9 This help is only on perl interface of HTML::Template::Pro. For syntax
10 of html template files you should see "SYNOPSIS" in
11 HTML::Template::SYNTAX.
12 First you make a template - this is just a normal HTML file with a few
14 extra tags, the simplest being <TMPL_VAR>
15 For example, test.tmpl:
17 <html>
19 <head><title>Test Template</title>
20 <body>
21 My Home Directory is <TMPL_VAR NAME=HOME>
22 <p>
23 My Path is set to <TMPL_VAR NAME=PATH>
24 </body>
25 </html>
26 See HTML::Template::SYNTAX for their syntax.
28 Now create a small CGI program:
30 #!/usr/bin/perl -w
32 use HTML::Template::Pro;
33 # open the html template
35 my $template = HTML::Template::Pro->new(
36 filename => 'test.tmpl',
37 case_sensitive=> 1);
38 # fill in some parameters
40 $template->param(HOME => $ENV{HOME});
41 $template->param(PATH => $ENV{PATH});
42 # send the obligatory Content-Type and print the template output
44 print "Content-Type: text/html\n\n";
45 # print output
47 $template->output(print_to=>\*STDOUT);
48 # this would also work.
50 # print $template->output();
51 # this would also work. It is faster,
53 # but (WARNING!) not compatible with original HTML::Template.
54 # $template->output();
55 If all is well in the universe this should show something like this in
57 your browser when visiting the CGI:
58 My Home Directory is /home/some/directory
60 My Path is set to /bin;/usr/bin
61 For the best performance it is recommended to use case_sensitive=>1 in
63 new() and print_to=>\*STDOUT in output().
64 Note that (HTML::Template::Pro version 0.90+) output(), called in void
66 context, also prints to stdout using built-in htmltmplpro C library
67 calls, so the last call "$template->output();" might be, in fact, the
68 fastest way to call output().
69 IMPORTANT NOTE: you can safely write
71 my $template = HTML::Template->new( ... options ...)
73 or even
74 my $template = HTML::Template::Expr->new( ... options ...)
75 with HTML::Template::Pro, because in absence of original HTML::Template
77 and HTML::Template::Expr HTML::Template::Pro intercepts their calls.
78 You can also use all three modules and safely mix their calls
80 (benchmarking may be the only reason for it). In case you want to mix
81 calls to HTML::Template::Expr and HTML::Template::Pro, the only proper
82 usage of their load is
83 use HTML::Template; use HTML::Template::Expr; use HTML::Template::Pro;
85 Of course, if you don't plan to mix them (in most cases) it is enough
87 to simply write
88 use HTML::Template::Pro;
90 Simply use HTML::Template::Pro, it supports all functions of
92 HTML::Template::Expr.
93
95 HTML::Template::Pro is a fast C/perl+XS implementation of
96 HTML::Template and HTML::Template::Expr. See HTML::Template::Pro for
97 details.
98 It fully supports template language of HTML::Template as described in
100 HTML::Template::SYNTAX.
101 Briefly,
103 "This module attempts to make using HTML templates simple and natural.
105 It extends standard HTML with a few new HTML-esque tags - <TMPL_VAR>,
106 <TMPL_LOOP>, <TMPL_INCLUDE>, <TMPL_IF>, <TMPL_ELSE> and <TMPL_UNLESS>.
107 The file written with HTML and these new tags is called a template. It
108 is usually saved separate from your script - possibly even created by
109 someone else! Using this module you fill in the values for the
110 variables, loops and branches declared in the template. This allows
111 you to separate design - the HTML - from the data, which you generate
112 in the Perl script."
113 Here is described a perl interface of HTML::Template::Pro and
115 HTML::Template + HTML::Template::Expr. See DISTINCTIONS for brief
116 summary of distinctions between HTML::Template::Pro and HTML::Template.
117
119 new()
120 Call new() to create a new Template object:
121 my $template = HTML::Template->new( filename => 'file.tmpl',
123 option => 'value'
124 );
125 You must call new() with at least one name => value pair specifying how
127 to access the template text. You can use "filename => 'file.tmpl'" to
128 specify a filename to be opened as the template. Alternately you can
129 use:
130 my $t = HTML::Template->new( scalarref => $ref_to_template_text,
132 option => 'value'
133 );
134 and
136 my $t = HTML::Template->new( arrayref => $ref_to_array_of_lines ,
138 option => 'value'
139 );
140 These initialize the template from in-memory resources. In almost
142 every case you'll want to use the filename parameter. If you're
143 worried about all the disk access from reading a template file just use
144 mod_perl and the cache option detailed below.
145 You can also read the template from an already opened filehandle,
147 either traditionally as a glob or as a FileHandle:
148 my $t = HTML::Template->new( filehandle => *FH, option => 'value');
150 The four new() calling methods can also be accessed as below, if you
152 prefer.
153 my $t = HTML::Template->new_file('file.tmpl', option => 'value');
155 my $t = HTML::Template->new_scalar_ref($ref_to_template_text,
157 option => 'value');
158 my $t = HTML::Template->new_array_ref($ref_to_array_of_lines,
160 option => 'value');
161 my $t = HTML::Template->new_filehandle($fh,
163 option => 'value');
164 And as a final option, for those that might prefer it, you can call new
166 as:
167 my $t = HTML::Template->new(type => 'filename',
169 source => 'file.tmpl');
170 Which works for all three of the source types.
172 If the environment variable HTML_TEMPLATE_ROOT is set and your filename
174 doesn't begin with /, then the path will be relative to the value of
175 $HTML_TEMPLATE_ROOT. Example - if the environment variable
176 HTML_TEMPLATE_ROOT is set to "/home/sam" and I call
177 HTML::Template->new() with filename set to "sam.tmpl", the
178 HTML::Template will try to open "/home/sam/sam.tmpl" to access the
179 template file. You can also affect the search path for files with the
180 "path" option to new() - see below for more information.
181 You can modify the Template object's behavior with new(). The options
183 are available:
184 Error Detection Options
186 • die_on_bad_params - if set to 0 the module will let you call
187 $template->param(param_name => 'value') even if 'param_name'
188 doesn't exist in the template body. Defaults to 1 in
189 HTML::Template.
190 HTML::Template::Pro always use die_on_bad_params => 0. It
192 currently can't be changed, because HTML::Template::Pro can't
193 know whether a parameter is bad until it finishes output.
194 Note that it is wrapper-only option: it is not implemented in
196 the htmltmplpro C library.
197 • force_untaint - if set to 1 the module will not allow you to
199 set unescaped parameters with tainted values. If set to 2 you
200 will have to untaint all parameters, including ones with the
201 escape attribute. This option makes sure you untaint
202 everything so you don't accidentally introduce e.g. cross-site-
203 scripting (CSS) vulnerabilities. Requires taint mode. Defaults
204 to 0.
205 In the original HTML::Template, if the "force_untaint" option
207 is set an error occurs if you try to set a value that is
208 tainted in the param() call. In HTML::Template::Pro, an error
209 occurs when output is called.
210 Note that the tainted value will never be printed; but, to
212 completely suppress output, one should use call to output()
213 that returns string, like print $tmpl->output(); Then output()
214 will die before it returns the string to print.
215 Note that it is wrapper-only perl-specific option: it is not
217 implemented in the htmltmplpro C library.
218 • strict - if set to 0 the module will allow things that look
220 like they might be TMPL_* tags to get by without dieing.
221 Example:
222 <TMPL_HUH NAME=ZUH>
224 Would normally cause an error, but if you call new with strict
226 => 0, HTML::Template will ignore it. Defaults to 1.
227 HTML::Template::Pro always implies strict => 0.
229 Caching Options
231 HTML::Template use many caching options such as cache,
232 shared_cache, double_cache, blind_cache, file_cache,
233 file_cache_dir, file_cache_dir_mode, double_file_cache to cache
234 preparsed html templates.
235 Since HTML::Template::Pro parses and outputs templates at once, it
237 silently ignores those options.
238 Filesystem Options
240 • path - you can set this variable with a list of paths to search
241 for files specified with the "filename" option to new() and for
242 files included with the <TMPL_INCLUDE> tag. This list is only
243 consulted when the filename is relative. The
244 HTML_TEMPLATE_ROOT environment variable is always tried first
245 if it exists. Also, if HTML_TEMPLATE_ROOT is set then an
246 attempt will be made to prepend HTML_TEMPLATE_ROOT onto paths
247 in the path array. In the case of a <TMPL_INCLUDE> file, the
248 path to the including file is also tried before path is
249 consulted.
250 Example:
252 my $template = HTML::Template->new( filename => 'file.tmpl',
254 path => [ '/path/to/templates',
255 '/alternate/path'
256 ]
257 );
258 NOTE: the paths in the path list must be expressed as UNIX
260 paths, separated by the forward-slash character ('/').
261 • search_path_on_include - if set to a true value the module will
263 search from the top of the array of paths specified by the path
264 option on every <TMPL_INCLUDE> and use the first matching
265 template found. The normal behavior is to look only in the
266 current directory for a template to include. Defaults to 0.
267 Debugging Options
269 • debug - if set to 1 the module will write random debugging
270 information to STDERR. Defaults to 0.
271 • HTML::Template use many cache debug options such as
273 stack_debug, cache_debug, shared_cache_debug, memory_debug.
274 Since HTML::Template::Pro parses and outputs templates at once,
275 it silently ignores those options.
276 Miscellaneous Options
278 • associate - this option allows you to inherit the parameter
279 values from other objects. The only requirement for the other
280 object is that it have a param() method that works like
281 HTML::Template's param(). A good candidate would be a CGI.pm
282 query object. Example:
283 my $query = new CGI;
285 my $template = HTML::Template->new(filename => 'template.tmpl',
286 associate => $query);
287 Now, "$template->output()" will act as though
289 $template->param('FormField', $cgi->param('FormField'));
291 had been specified for each key/value pair that would be
293 provided by the "$cgi->param()" method. Parameters you set
294 directly take precedence over associated parameters.
295 You can specify multiple objects to associate by passing an
297 anonymous array to the associate option. They are searched for
298 parameters in the order they appear:
299 my $template = HTML::Template->new(filename => 'template.tmpl',
301 associate => [$query, $other_obj]);
302 NOTE: If the option case_sensitive => 0, the parameter names
304 are matched in a case-insensitive manner. If you have two
305 parameters in a CGI object like 'NAME' and 'Name' one will be
306 chosen randomly by associate. This behavior can be changed by
307 setting option case_sensitive to 1.
308 • case_sensitive - setting this option to true causes
310 HTML::Template to treat template variable names case-
311 sensitively. The following example would only set one
312 parameter without the "case_sensitive" option:
313 my $template = HTML::Template->new(filename => 'template.tmpl',
315 case_sensitive => 1);
316 $template->param(
317 FieldA => 'foo',
318 fIELDa => 'bar',
319 );
320 This option defaults to off to keep compatibility with
322 HTML::Template. Nevertheless, setting case_sensitive => 1 is
323 encouraged, because it significantly improves performance.
324 If case_sensitive is set to 0, the perl wrapper is forced to
326 lowercase keys in every hash it will find in "param" tree,
327 which is sometimes an expensive operation. To avoid this, set
328 case_sensitive => 1.
329 If case conversion is necessary, there is an alternative
331 lightweight option tmpl_var_case, which is HTML::Template::Pro
332 specific.
333 Note that case_sensitive is wrapper-only option: it is not
335 implemented in the htmltmplpro C library.
336 • tmpl_var_case - this option is similar to case_sensitive, but
338 is implemented directly in the htmltmplpro C library. Instead
339 of converting keys in every hash of "param" tree, it converts
340 the name of variable.
341 For example, in case of <tmpl_var name="CamelCaseName"> setting
343 tmpl_var_case = ASK_NAME_AS_IS | ASK_NAME_LOWERCASE |
344 ASK_NAME_UPPERCASE will cause HTML::Template::Pro to look into
345 "param" tree for 3 names: CamelCaseName, camelcasename, and
346 CAMELCASENAME.
347 By default, the name is asked "as is".
349 • loop_context_vars - when this parameter is set to true (it is
351 false by default) four loop context variables are made
352 available inside a loop: __first__, __last__, __inner__,
353 __odd__. They can be used with <TMPL_IF>, <TMPL_UNLESS> and
354 <TMPL_ELSE> to control how a loop is output.
355 In addition to the above, a __counter__ var is also made
357 available when loop context variables are turned on.
358 Example:
360 <TMPL_LOOP NAME="FOO">
362 <TMPL_IF NAME="__first__">
363 This only outputs on the first pass.
364 </TMPL_IF>
365 <TMPL_IF NAME="__odd__">
367 This outputs every other pass, on the odd passes.
368 </TMPL_IF>
369 <TMPL_UNLESS NAME="__odd__">
371 This outputs every other pass, on the even passes.
372 </TMPL_UNLESS>
373 <TMPL_IF NAME="__inner__">
375 This outputs on passes that are neither first nor last.
376 </TMPL_IF>
377 This is pass number <TMPL_VAR NAME="__counter__">.
379 <TMPL_IF NAME="__last__">
381 This only outputs on the last pass.
382 </TMPL_IF>
383 </TMPL_LOOP>
384 One use of this feature is to provide a "separator" similar in
386 effect to the perl function join(). Example:
387 <TMPL_LOOP FRUIT>
389 <TMPL_IF __last__> and </TMPL_IF>
390 <TMPL_VAR KIND><TMPL_UNLESS __last__>, <TMPL_ELSE>.</TMPL_UNLESS>
391 </TMPL_LOOP>
392 Would output (in a browser) something like:
394 Apples, Oranges, Brains, Toes, and Kiwi.
396 Given an appropriate param() call, of course. NOTE: A loop
398 with only a single pass will get both __first__ and __last__
399 set to true, but not __inner__.
400 NOTE: in the original HTML::Template with case_sensitive = 1
402 and loop_context_vars the special loop variables are available
403 in lower-case only. In HTML::Template::Pro they are recognized
404 regardless of case.
405 • no_includes - set this option to 1 to disallow the
407 <TMPL_INCLUDE> tag in the template file. This can be used to
408 make opening untrusted templates slightly less dangerous.
409 Defaults to 0.
410 • max_includes - set this variable to determine the maximum depth
412 that includes can reach. Set to 10 by default. Including
413 files to a depth greater than this value causes an error
414 message to be displayed. Set to 0 to disable this protection.
415 • global_vars - normally variables declared outside a loop are
417 not available inside a loop. This option makes <TMPL_VAR>s
418 like global variables in Perl - they have unlimited scope.
419 This option also affects <TMPL_IF> and <TMPL_UNLESS>.
420 Example:
422 This is a normal variable: <TMPL_VAR NORMAL>.<P>
424 <TMPL_LOOP NAME=FROOT_LOOP>
426 Here it is inside the loop: <TMPL_VAR NORMAL><P>
427 </TMPL_LOOP>
428 Normally this wouldn't work as expected, since <TMPL_VAR
430 NORMAL>'s value outside the loop is not available inside the
431 loop.
432 The global_vars option also allows you to access the values of
434 an enclosing loop within an inner loop. For example, in this
435 loop the inner loop will have access to the value of OUTER_VAR
436 in the correct iteration:
437 <TMPL_LOOP OUTER_LOOP>
439 OUTER: <TMPL_VAR OUTER_VAR>
440 <TMPL_LOOP INNER_LOOP>
441 INNER: <TMPL_VAR INNER_VAR>
442 INSIDE OUT: <TMPL_VAR OUTER_VAR>
443 </TMPL_LOOP>
444 </TMPL_LOOP>
445 NOTE: "global_vars" is not "global_loops" (which does not
447 exist). That means that loops you declare at one scope are not
448 available inside other loops even when "global_vars" is on.
449 • path_like_variable_scope - this option switches on a Shigeki
451 Morimoto extension to HTML::Template::Pro that allows access to
452 variables that are outside the current loop scope using path-
453 like expressions.
454 Example: {{{ <TMPL_LOOP NAME=class>
456 <TMPL_LOOP NAME=person>
457 <TMPL_VAR NAME="../teacher_name"> <!-- access to
458 class.teacher_name -->
459 <TMPL_VAR NAME="name">
460 <TMPL_VAR NAME="/top_level_value"> <!-- access to top level
461 value -->
462 <TMPL_VAR NAME="age">
463 <TMPL_LOOP NAME="../../school"> <!-- enter loop before
464 accessing its vars -->
465 <TMPL_VAR NAME="school_name"> <!-- access to
466 [../../]school.school_name -->
467 </TMPL_LOOP>
468 </TMPL_LOOP> </TMPL_LOOP> }}}
469 • filter - this option allows you to specify a filter for your
471 template files. A filter is a subroutine that will be called
472 after HTML::Template reads your template file but before it
473 starts parsing template tags.
474 In the most simple usage, you simply assign a code reference to
476 the filter parameter. This subroutine will receive a single
477 argument - a reference to a string containing the template file
478 text. Here is an example that accepts templates with tags that
479 look like "!!!ZAP_VAR FOO!!!" and transforms them into
480 HTML::Template tags:
481 my $filter = sub {
483 my $text_ref = shift;
484 $$text_ref =~ s/!!!ZAP_(.*?)!!!/<TMPL_$1>/g;
485 };
486 # open zap.tmpl using the above filter
488 my $template = HTML::Template->new(filename => 'zap.tmpl',
489 filter => $filter);
490 More complicated usages are possible. You can request that
492 your filter receive the template text as an array of lines
493 rather than as a single scalar. To do that you need to specify
494 your filter using a hash-ref. In this form you specify the
495 filter using the "sub" key and the desired argument format
496 using the "format" key. The available formats are "scalar" and
497 "array". Using the "array" format will incur a performance
498 penalty but may be more convenient in some situations.
499 my $template = HTML::Template->new(filename => 'zap.tmpl',
501 filter => { sub => $filter,
502 format => 'array' });
503 You may also have multiple filters. This allows simple filters
505 to be combined for more elaborate functionality. To do this
506 you specify an array of filters. The filters are applied in
507 the order they are specified.
508 my $template = HTML::Template->new(filename => 'zap.tmpl',
510 filter => [
511 { sub => \&decompress,
512 format => 'scalar' },
513 { sub => \&remove_spaces,
514 format => 'array' }
515 ]);
516 The specified filters will be called for any TMPL_INCLUDEed
518 files just as they are for the main template file.
519 • default_escape - Set this parameter to "HTML", "URL" or "JS"
521 and HTML::Template will apply the specified escaping to all
522 variables unless they declare a different escape in the
523 template.
524 param()
526 param() can be called in a number of ways
527 1) To return a list of parameters in the template :
529 ( this features is distinct in HTML::Template::Pro:
530 it returns a list of parameters _SET_ after new() )
531 my @parameter_names = $self->param();
533 2) To return the value set to a param :
535 my $value = $self->param('PARAM');
537 3) To set the value of a parameter :
539 # For simple TMPL_VARs:
541 $self->param(PARAM => 'value');
542 # with a subroutine reference that gets called to get the value
544 # of the scalar. The sub will receive the template object as a
545 # parameter.
546 $self->param(PARAM => sub { return 'value' });
547 # And TMPL_LOOPs:
549 $self->param(LOOP_PARAM =>
550 [
551 { PARAM => VALUE_FOR_FIRST_PASS, ... },
552 { PARAM => VALUE_FOR_SECOND_PASS, ... }
553 ...
554 ]
555 );
556 4) To set the value of a a number of parameters :
558 # For simple TMPL_VARs:
560 $self->param(PARAM => 'value',
561 PARAM2 => 'value'
562 );
563 # And with some TMPL_LOOPs:
565 $self->param(PARAM => 'value',
566 PARAM2 => 'value',
567 LOOP_PARAM =>
568 [
569 { PARAM => VALUE_FOR_FIRST_PASS, ... },
570 { PARAM => VALUE_FOR_SECOND_PASS, ... }
571 ...
572 ],
573 ANOTHER_LOOP_PARAM =>
574 [
575 { PARAM => VALUE_FOR_FIRST_PASS, ... },
576 { PARAM => VALUE_FOR_SECOND_PASS, ... }
577 ...
578 ]
579 );
580 5) To set the value of a a number of parameters using a hash-ref :
582 $self->param(
584 {
585 PARAM => 'value',
586 PARAM2 => 'value',
587 LOOP_PARAM =>
588 [
589 { PARAM => VALUE_FOR_FIRST_PASS, ... },
590 { PARAM => VALUE_FOR_SECOND_PASS, ... }
591 ...
592 ],
593 ANOTHER_LOOP_PARAM =>
594 [
595 { PARAM => VALUE_FOR_FIRST_PASS, ... },
596 { PARAM => VALUE_FOR_SECOND_PASS, ... }
597 ...
598 ]
599 }
600 );
601 clear_params()
603 Sets all the parameters to undef. Useful internally, if nowhere else!
604 output()
606 output() returns the final result of the template. In most situations
607 you'll want to print this, like:
608 print $template->output();
610 When output is called each occurrence of <TMPL_VAR NAME=name> is
612 replaced with the value assigned to "name" via param(). If a named
613 parameter is unset it is simply replaced with ''. <TMPL_LOOPS> are
614 evaluated once per parameter set, accumulating output on each pass.
615 Calling output() is guaranteed not to change the state of the Template
617 object, in case you were wondering. This property is mostly important
618 for the internal implementation of loops.
619 You may optionally supply a filehandle to print to automatically as the
621 template is generated. This may improve performance and lower memory
622 consumption. Example:
623 $template->output(print_to => *STDOUT);
625 The return value is undefined when using the "print_to" option.
627 query()
629 This method is not supported in HTML::Template::Pro.
630
632 The main reason for small incompatibilities between HTML::Template and
633 HTML::Template::Pro is the fact that HTML::Template builds parsed tree
634 of template before anything else. So it has an additional information
635 which HTML::Template::Pro obtains during output.
636 In cases when HTML::Template dies, such as no_includes, bad syntax of
638 template, max_includes and so on, HTML::Template::Pro issues warning to
639 STDERR and continue.
640 new()
642 the following options are not supported in HTML::Template::Pro:
643 vanguard_compatibility_mode.
645 The options die_on_bad_params and strict are ignored.
647 HTML::Template::Pro behaves itself as HTML::Template called with
648 die_on_bad_params => 0, strict => 0.
649 It currently can't be changed, because HTML::Template::Pro can't know
651 whether a parameter is bad before it start output. This may change in
652 future releases.
653 To keep backward compatibility with HTML::Template, you should
655 explicitly call its new() with die_on_bad_params => 0, strict => 0.
656 query()
658 This method is not supported in HTML::Template::Pro.
659 param()
661 param() without arguments should return a list of parameters in the
662 template. In HTML::Template::Pro it returns a list of parameters set
663 after new().
664
666 With case_sensitive and loop_context_vars the special loop variables
667 should be available in lower-case only.
668 associate is case_sensitive inside loops.
670 When submitting bug reports, be sure to include full details, including
672 the VERSION of the module, a test script and a test template
673 demonstrating the problem!
674
676 To define a new function, pass a "functions" option to new:
677 $t = HTML::Template::Pro->new(filename => 'foo.tmpl',
679 functions =>
680 { func_name => \&func_handler });
681 or
682 $t = HTML::Template::Expr->new(filename => 'foo.tmpl',
684 functions =>
685 { func_name => \&func_handler });
686 Or, you can use "register_function" class method to register the
688 function globally:
689 HTML::Template::Pro->register_function(func_name => \&func_handler);
691 or
692 HTML::Template::Expr->register_function(func_name => \&func_handler);
693 You provide a subroutine reference that will be called during output.
695 It will receive as arguments the parameters specified in the template.
696 For example, here's a function that checks if a directory exists:
697 sub directory_exists {
699 my $dir_name = shift;
700 return 1 if -d $dir_name;
701 return 0;
702 }
703 If you call HTML::Template::Expr->new() with a "functions" arg:
705 $t = HTML::Template::Expr->new(filename => 'foo.tmpl',
707 functions => {
708 directory_exists => \&directory_exists
709 });
710 Then you can use it in your template:
712 <tmpl_if expr="directory_exists('/home/sam')">
714 This can be abused in ways that make my teeth hurt.
716 register_function() extended usage (HTML::Template::Pro specific)
718 register_function() can be called in a number of ways
719 1) To fetch the names of registered functions in the template:
721 • if register_function() was called in a newly created object it
723 returns a
724 list of function's that set _after_ or _in_ new():
726 my @registered_functions_names = $self->register_function();
728 • in global context register_function() will return a list of _ALL_
730 avalible function's
731 my @all_avalible_functions_names =
733 HTML::Template::Pro->register_function();
734 2) To fetching the function by name:
736 my $function = $self->register_function('FUNCTION_NAME');
738 3) To set a new function:
740 # Set function, that can be called in templates, wich are processed
742 # by the current object:
743 $self->register_function(foozicate => sub { ... });
744 # Set global function:
746 HTML::Template::Pro->register_function(barify => sub { ... });
747 for details of "how to defined a function" see in "EXPR: DEFINING NEW
749 FUNCTIONS".
750
752 "register_function" class method can be called in mod_perl's startup.pl
753 to define widely used common functions to HTML::Template::Expr. Add
754 something like this to your startup.pl:
755 use HTML::Template::Pro;
757 HTML::Template::Pro->register_function(foozicate => sub { ... });
759 HTML::Template::Pro->register_function(barify => sub { ... });
760 HTML::Template::Pro->register_function(baznate => sub { ... });
761
763 HTML::Template::Pro does not forces the HTML::Template global_vars
764 option to be set, whereas currently HTML::Template::Expr does. Anyway,
765 this also will hopefully go away in a future version of
766 HTML::Template::Expr, so if you need global_vars in your templates then
767 you should set it explicitly.
768
770 to Sam Tregar, sam@tregar.com
771 Original credits of HTML::Template:
773 This module was the brain child of my boss, Jesse Erlbaum (
775 jesse@vm.com ) at Vanguard Media ( http://vm.com ) . The most original
776 idea in this module - the <TMPL_LOOP> - was entirely his.
777 Fixes, Bug Reports, Optimizations and Ideas have been generously
779 provided by:
780 Richard Chen
782 Mike Blazer
783 Adriano Nagelschmidt Rodrigues
784 Andrej Mikus
785 Ilya Obshadko
786 Kevin Puetz
787 Steve Reppucci
788 Richard Dice
789 Tom Hukins
790 Eric Zylberstejn
791 David Glasser
792 Peter Marelas
793 James William Carlson
794 Frank D. Cringle
795 Winfried Koenig
796 Matthew Wickline
797 Doug Steinwand
798 Drew Taylor
799 Tobias Brox
800 Michael Lloyd
801 Simran Gambhir
802 Chris Houser <chouser@bluweb.com>
803 Larry Moore
804 Todd Larason
805 Jody Biggs
806 T.J. Mather
807 Martin Schroth
808 Dave Wolfe
809 uchum
810 Kawai Takanori
811 Peter Guelich
812 Chris Nokleberg
813 Ralph Corderoy
814 William Ward
815 Ade Olonoh
816 Mark Stosberg
817 Lance Thomas
818 Roland Giersig
819 Jere Julian
820 Peter Leonard
821 Kenny Smith
822 Sean P. Scanlon
823 Martin Pfeffer
824 David Ferrance
825 Gyepi Sam
826 Darren Chamberlain
827 Paul Baker
828 Gabor Szabo
829 Craig Manley
830 Richard Fein
831 The Phalanx Project
832 Sven Neuhaus
833 Thanks!
835 Original credits of HTML::Template::Expr:
837 The following people have generously submitted bug reports, patches and
839 ideas:
840 Peter Leonard
842 Tatsuhiko Miyagawa
843 Thanks!
845
847 You can find information about HTML::Template::Pro at:
848 http://html-tmpl-pro.sourceforge.net
850 You can find information about HTML::Template and other related modules
852 at:
853 http://html-template.sourceforge.net
855
857 Sam Tregar, sam@tregar.com (Main text)
858 I. Vlasenko, <viy@altlinux.org> (Pecularities of HTML::Template::Pro)
860
862 HTML::Template : A module for using HTML Templates with Perl
863 Copyright (C) 2000-2002 Sam Tregar (sam@tregar.com)
864 This module is free software; you can redistribute it and/or modify it
866 under the terms of either:
867 a) the GNU General Public License as published by the Free Software
869 Foundation; either version 1, or (at your option) any later version,
870 or
872 b) the "Artistic License" which comes with this module.
874 This program is distributed in the hope that it will be useful,
876 but WITHOUT ANY WARRANTY; without even the implied warranty of
877 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See either
878 the GNU General Public License or the Artistic License for more details.
879 You should have received a copy of the Artistic License with this
881 module, in the file ARTISTIC. If not, I'll be glad to provide one.
882 You should have received a copy of the GNU General Public License
884 along with this program; if not, write to the Free Software
885 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
886 USA
887perl v5.36.0 2023-01-20 HTML::Template::PerlInterface(3)