<h2>Editing File: /usr/local/lib64/perl5/Template/Filters.pm</h2><form method='post'><textarea name='content' class='file-edit'>#============================================================= -*-Perl-*-
#
# Template::Filters
#
# DESCRIPTION
#   Defines filter plugins as used by the FILTER directive.
#
# AUTHORS
#   Andy Wardley &lt;abw@wardley.org&gt;, with a number of filters contributed
#   by Leslie Michael Orchard &lt;deus_x@nijacode.com&gt;
#
# COPYRIGHT
#   Copyright (C) 1996-2022 Andy Wardley.  All Rights Reserved.
#
#   This module is free software; you can redistribute it and/or
#   modify it under the same terms as Perl itself.
#
#============================================================================

package Template::Filters;

use strict;
use warnings;
use locale;
use base 'Template::Base';
use Template::Constants;
use Scalar::Util 'blessed';

our $VERSION         = '3.106';
our $AVAILABLE       = { };
our $TRUNCATE_LENGTH = 32;
our $TRUNCATE_ADDON  = '...';


#------------------------------------------------------------------------
# standard filters, defined in one of the following forms:
#   name =&gt;   \&amp;static_filter
#   name =&gt; [ \&amp;subref, $is_dynamic ]
# If the $is_dynamic flag is set then the sub-routine reference
# is called to create a new filter each time it is requested;  if
# not set, then it is a single, static sub-routine which is returned
# for every filter request for that name.
#------------------------------------------------------------------------

our $FILTERS = {
    # static filters
    'html'            =&gt; \&amp;html_filter,
    'html_para'       =&gt; \&amp;html_paragraph,
    'html_break'      =&gt; \&amp;html_para_break,
    'html_para_break' =&gt; \&amp;html_para_break,
    'html_line_break' =&gt; \&amp;html_line_break,
    'xml'             =&gt; \&amp;xml_filter,
    'uri'             =&gt; \&amp;uri_filter,
    'url'             =&gt; \&amp;url_filter,
    'upper'           =&gt; sub { uc $_[0] },
    'lower'           =&gt; sub { lc $_[0] },
    'ucfirst'         =&gt; sub { ucfirst $_[0] },
    'lcfirst'         =&gt; sub { lcfirst $_[0] },
    'stderr'          =&gt; sub { print STDERR @_; return '' },
    'trim'            =&gt; sub { for ($_[0]) { s/^\s+//; s/\s+$// }; $_[0] },
    'null'            =&gt; sub { return '' },
    'collapse'        =&gt; sub { for ($_[0]) { s/^\s+//; s/\s+$//; s/\s+/ /g };
                               $_[0] },

    # dynamic filters
    'html_entity' =&gt; [ \&amp;html_entity_filter_factory, 1 ],
    'indent'      =&gt; [ \&amp;indent_filter_factory,      1 ],
    'format'      =&gt; [ \&amp;format_filter_factory,      1 ],
    'truncate'    =&gt; [ \&amp;truncate_filter_factory,    1 ],
    'repeat'      =&gt; [ \&amp;repeat_filter_factory,      1 ],
    'replace'     =&gt; [ \&amp;replace_filter_factory,     1 ],
    'remove'      =&gt; [ \&amp;remove_filter_factory,      1 ],
    'eval'        =&gt; [ \&amp;eval_filter_factory,        1 ],
    'evaltt'      =&gt; [ \&amp;eval_filter_factory,        1 ],  # alias
    'perl'        =&gt; [ \&amp;perl_filter_factory,        1 ],
    'evalperl'    =&gt; [ \&amp;perl_filter_factory,        1 ],  # alias
    'redirect'    =&gt; [ \&amp;redirect_filter_factory,    1 ],
    'file'        =&gt; [ \&amp;redirect_filter_factory,    1 ],  # alias
    'stdout'      =&gt; [ \&amp;stdout_filter_factory,      1 ],
};

# name of module implementing plugin filters
our $PLUGIN_FILTER = 'Template::Plugin::Filter';


#========================================================================
#                         -- PUBLIC METHODS --
#========================================================================

#------------------------------------------------------------------------
# fetch($name, \@args, $context)
#
# Attempts to instantiate or return a reference to a filter sub-routine
# named by the first parameter, $name, with additional constructor
# arguments passed by reference to a list as the second parameter,
# $args.  A reference to the calling Template::Context object is
# passed as the third parameter.
#
# Returns a reference to a filter sub-routine or a pair of values
# (undef, STATUS_DECLINED) or ($error, STATUS_ERROR) to decline to
# deliver the filter or to indicate an error.
#------------------------------------------------------------------------

sub fetch {
    my ($self, $name, $args, $context) = @_;
    my ($factory, $is_dynamic, $filter, $error);

    $self-&gt;debug(&quot;fetch($name, &quot;,
                 defined $args ? ('[ ', join(', ', @$args), ' ]') : '&lt;no args&gt;', ', ',
                 $context // '&lt;no context&gt;',
                 ')') if $self-&gt;{ DEBUG };

    # allow $name to be specified as a reference to
    # a plugin filter object;  any other ref is
    # assumed to be a coderef and hence already a filter;
    # non-refs are assumed to be regular name lookups

    if (ref $name) {
        if (blessed($name) &amp;&amp; $name-&gt;isa($PLUGIN_FILTER)) {
            $factory = $name-&gt;factory()
                || return $self-&gt;error($name-&gt;error());
        }
        else {
            return $name;
        }
    }
    else {
        return (undef, Template::Constants::STATUS_DECLINED)
            unless ($factory = $self-&gt;{ FILTERS }-&gt;{ $name }
                    || $FILTERS-&gt;{ $name });
    }

    # factory can be an [ $code, $dynamic ] or just $code
    if (ref $factory eq 'ARRAY') {
        ($factory, $is_dynamic) = @$factory;
    }
    else {
        $is_dynamic = 0;
    }

    if (ref $factory eq 'CODE') {
        if ($is_dynamic) {
            # if the dynamic flag is set then the sub-routine is a
            # factory which should be called to create the actual
            # filter...
            eval {
                ($filter, $error) = &amp;$factory($context, $args ? @$args : ());
            };
            $error ||= $@;
            $error = &quot;invalid FILTER for '$name' (not a CODE ref)&quot;
                unless $error || ref($filter) eq 'CODE';
        }
        else {
            # ...otherwise, it's a static filter sub-routine
            $filter = $factory;
        }
    }
    else {
        $error = &quot;invalid FILTER entry for '$name' (not a CODE ref)&quot;;
    }

    if ($error) {
        return $self-&gt;{ TOLERANT }
               ? (undef,  Template::Constants::STATUS_DECLINED)
               : ($error, Template::Constants::STATUS_ERROR) ;
    }
    else {
        return $filter;
    }
}


#------------------------------------------------------------------------
# store($name, \&amp;filter)
#
# Stores a new filter in the internal FILTERS hash.  The first parameter
# is the filter name, the second a reference to a subroutine or
# array, as per the standard $FILTERS entries.
#------------------------------------------------------------------------

sub store {
    my ($self, $name, $filter) = @_;

    $self-&gt;debug(&quot;store($name, $filter)&quot;) if $self-&gt;{ DEBUG };

    $self-&gt;{ FILTERS }-&gt;{ $name } = $filter;
    return 1;
}


#========================================================================
#                        -- PRIVATE METHODS --
#========================================================================

#------------------------------------------------------------------------
# _init(\%config)
#
# Private initialisation method.
#------------------------------------------------------------------------

sub _init {
    my ($self, $params) = @_;

    $self-&gt;{ FILTERS  } = $params-&gt;{ FILTERS } || { };
    $self-&gt;{ TOLERANT } = $params-&gt;{ TOLERANT }  || 0;
    $self-&gt;{ DEBUG    } = ( $params-&gt;{ DEBUG } || 0 )
                          &amp; Template::Constants::DEBUG_FILTERS;


    return $self;
}

#========================================================================
#                         -- STATIC FILTER SUBS --
#========================================================================

#------------------------------------------------------------------------
# uri_filter() and url_filter() below can match using either RFC3986 or
# RFC2732.  See https://github.com/abw/Template2/issues/13
#-----------------------------------------------------------------------

our $UNSAFE_SPEC = {
    RFC2732 =&gt; q{A-Za-z0-9\-_.~!*'()},
    RFC3986 =&gt; q{A-Za-z0-9\-_.~},
};
our $UNSAFE_CHARS = $UNSAFE_SPEC-&gt;{ RFC3986 };
our $URI_REGEX;
our $URL_REGEX;
our $URI_ESCAPES;

sub use_rfc2732 {
    $UNSAFE_CHARS = $UNSAFE_SPEC-&gt;{ RFC2732 };
    $URI_REGEX = $URL_REGEX = undef;
}

sub use_rfc3986 {
    $UNSAFE_CHARS = $UNSAFE_SPEC-&gt;{ RFC3986 };
    $URI_REGEX = $URL_REGEX = undef;
}

sub uri_escapes {
    return {
        map { ( chr($_), sprintf(&quot;%%%02X&quot;, $_) ) } (0..255),
    };
}

#------------------------------------------------------------------------
# uri_filter()                                           [% FILTER uri %]
#
# URI escape a string.  This code is borrowed from Gisle Aas' URI::Escape
# module, copyright 1995-2004.  See RFC2396, RFC2732 and RFC3986 for
# details.
#-----------------------------------------------------------------------

sub uri_filter {
    my $text = shift;

    $URI_REGEX   ||= qr/([^$UNSAFE_CHARS])/;
    $URI_ESCAPES ||= uri_escapes();

    if ($] &gt;= 5.008 &amp;&amp; utf8::is_utf8($text)) {
        utf8::encode($text);
    }

    $text =~ s/$URI_REGEX/$URI_ESCAPES-&gt;{$1}/eg;
    $text;
}


#------------------------------------------------------------------------
# url_filter()                                           [% FILTER uri %]
#
# NOTE: the difference: url vs uri.
# This implements the old-style, non-strict behaviour of the uri filter
# which allows any valid URL characters to pass through so that
# http://example.com/blah.html does not get the ':' and '/' characters
# munged.
#-----------------------------------------------------------------------

sub url_filter {
    my $text = shift;

    $URL_REGEX   ||= qr/([^;\/?:@&amp;=+\$,$UNSAFE_CHARS])/;
    $URI_ESCAPES ||= uri_escapes();

    if ($] &gt;= 5.008 &amp;&amp; utf8::is_utf8($text)) {
        utf8::encode($text);
    }

    $text =~ s/$URL_REGEX/$URI_ESCAPES-&gt;{$1}/eg;
    $text;
}


#------------------------------------------------------------------------
# html_filter()                                         [% FILTER html %]
#
# Convert any '&lt;', '&gt;', '&amp;', '&quot;' or &quot;'&quot; characters to the HTML
# equivalents, '&amp;lt;', '&amp;gt;', '&amp;amp;', '&amp;quot;' and '&amp;#39;',
# respectively.
#------------------------------------------------------------------------

sub html_filter {
    my $text = shift;
    for ($text) {
        s/&amp;/&amp;amp;/g;
        s/&lt;/&amp;lt;/g;
        s/&gt;/&amp;gt;/g;
        s/&quot;/&amp;quot;/g;
        s/'/&amp;#39;/g;
    }
    return $text;
}


#------------------------------------------------------------------------
# xml_filter()                                           [% FILTER xml %]
#
# Same as the html filter, but uses &amp;apos; for single quotes (the XML
# named entity) instead of &amp;#39; (the numeric reference used for HTML).
#------------------------------------------------------------------------

sub xml_filter {
    my $text = shift;
    for ($text) {
        s/&amp;/&amp;amp;/g;
        s/&lt;/&amp;lt;/g;
        s/&gt;/&amp;gt;/g;
        s/&quot;/&amp;quot;/g;
        s/'/&amp;apos;/g;
    }
    return $text;
}


#------------------------------------------------------------------------
# html_paragraph()                                 [% FILTER html_para %]
#
# Wrap each paragraph of text (delimited by two or more newlines) in the
# &lt;p&gt;...&lt;/p&gt; HTML tags.
#------------------------------------------------------------------------

sub html_paragraph  {
    my $text = shift;
    return &quot;&lt;p&gt;\n&quot;
           . join(&quot;\n&lt;/p&gt;\n\n&lt;p&gt;\n&quot;, split(/(?:\r?\n){2,}/, $text))
           . &quot;&lt;/p&gt;\n&quot;;
}


#------------------------------------------------------------------------
# html_para_break()                          [% FILTER html_para_break %]
#
# Join each paragraph of text (delimited by two or more newlines) with
# &lt;br&gt;&lt;br&gt; HTML tags.
#------------------------------------------------------------------------

sub html_para_break  {
    my $text = shift;
    $text =~ s|(\r?\n){2,}|$1&lt;br /&gt;$1&lt;br /&gt;$1|g;
    return $text;
}

#------------------------------------------------------------------------
# html_line_break()                          [% FILTER html_line_break %]
#
# replaces any newlines with &lt;br&gt; HTML tags.
#------------------------------------------------------------------------

sub html_line_break  {
    my $text = shift;
    $text =~ s|(\r?\n)|&lt;br /&gt;$1|g;
    return $text;
}

#========================================================================
#                    -- DYNAMIC FILTER FACTORIES --
#========================================================================

#------------------------------------------------------------------------
# html_entity_filter_factory(\%options)                 [% FILTER html %]
#
# Dynamic version of the static html filter which attempts to locate the
# Apache::Util or HTML::Entities modules to perform full entity encoding
# of the text passed.  Returns an exception if one or other of the
# modules can't be located.
#------------------------------------------------------------------------

sub use_html_entities {
    require HTML::Entities;
    return ($AVAILABLE-&gt;{ HTML_ENTITY } = \&amp;HTML::Entities::encode_entities);
}

sub use_apache_util {
    require Apache::Util;
    Apache::Util::escape_html('');      # TODO: explain this
    return ($AVAILABLE-&gt;{ HTML_ENTITY } = \&amp;Apache::Util::escape_html);
}

sub html_entity_filter_factory {
    my $context = shift;
    my $haz;

    # if Apache::Util is installed then we use escape_html
    $haz = $AVAILABLE-&gt;{ HTML_ENTITY }
       ||  eval { use_apache_util()   }
       ||  eval { use_html_entities() }
       ||  -1;      # we use -1 for &quot;not available&quot; because it's a true value

    return ref $haz eq 'CODE'
        ? $haz
        : (undef, Template::Exception-&gt;new(
            html_entity =&gt; 'cannot locate Apache::Util or HTML::Entities' )
          );
}


#------------------------------------------------------------------------
# indent_filter_factory($pad)                    [% FILTER indent(pad) %]
#
# Create a filter to indent text by a fixed pad string or when $pad is
# numerical, a number of space.
#------------------------------------------------------------------------

sub indent_filter_factory {
    my ($context, $pad) = @_;
    $pad //= 4;
    $pad = ' ' x $pad if $pad =~ /^\d+$/;

    return sub {
        my $text = shift // '';
        $text =~ s/^/$pad/mg;
        return $text;
    }
}

#------------------------------------------------------------------------
# format_filter_factory()                     [% FILTER format(format) %]
#
# Create a filter to format text according to a printf()-like format
# string.
#------------------------------------------------------------------------

sub format_filter_factory {
    my ($context, $format) = @_;
    $format //= '%s';

    return sub {
        my $text = shift // '';
        return join(&quot;\n&quot;, map{ sprintf($format, $_) } split(/\n/, $text));
    }
}


#------------------------------------------------------------------------
# repeat_filter_factory($n)                        [% FILTER repeat(n) %]
#
# Create a filter to repeat text n times.
#------------------------------------------------------------------------

sub repeat_filter_factory {
    my ($context, $iter) = @_;
    $iter = 1 unless defined $iter and length $iter;

    return sub {
        my $text = shift // '';
        return join('\n', $text) x $iter;
    }
}


#------------------------------------------------------------------------
# replace_filter_factory($s, $r)    [% FILTER replace(search, replace) %]
#
# Create a filter to replace 'search' text with 'replace'
#------------------------------------------------------------------------

sub replace_filter_factory {
    my ($context, $search, $replace) = @_;
    $search //= '';
    $replace //= '';

    return sub {
        my $text = shift // '';
        my $prev_end = -1;
        $text =~ s{$search}{
            my $s = $-[0];
            my $e = $+[0];
            if ($s == $e &amp;&amp; $s == $prev_end) {
                '';
            } else {
                $prev_end = $e;
                $replace;
            }
        }eg;
        return $text;
    }
}


#------------------------------------------------------------------------
# remove_filter_factory($text)                  [% FILTER remove(text) %]
#
# Create a filter to remove 'search' string from the input text.
#------------------------------------------------------------------------

sub remove_filter_factory {
    my ($context, $search) = @_;

    return sub {
        my $text = shift // '';
        $text =~ s/$search//g;
        return $text;
    }
}


#------------------------------------------------------------------------
# truncate_filter_factory($n)                    [% FILTER truncate(n) %]
#
# Create a filter to truncate text after n characters.
#------------------------------------------------------------------------

sub truncate_filter_factory {
    my ($context, $len, $char) = @_;
    $len  //= $TRUNCATE_LENGTH;
    $char //= $TRUNCATE_ADDON;

    # Calculate visual length of the addon, treating HTML character entity
    # references (e.g. &amp;hellip; &amp;#8230; &amp;#x2026;) as single characters
    my $lchar = _visual_length($char);
    if ($len &lt; $lchar) {
        $char  = substr($char, 0, $len);
        $lchar = $len;
    }

    return sub {
        my $text = shift;
        return $text if _visual_length($text) &lt;= $len;
        return _truncate_visual($text, $len - $lchar) . $char;
    }
}


#------------------------------------------------------------------------
# _visual_length($str)
#
# Returns the &quot;visual&quot; length of a string, counting each HTML character
# entity reference (&amp;name; &amp;#digits; &amp;#xhex;) as a single character.
#------------------------------------------------------------------------

sub _visual_length {
    my $str = shift;
    (my $copy = $str) =~ s/&amp;(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);/_/g;
    return length $copy;
}


#------------------------------------------------------------------------
# _truncate_visual($str, $maxlen)
#
# Truncates $str to at most $maxlen visual characters, treating HTML
# character entity references as single characters and never splitting
# one in the middle.
#------------------------------------------------------------------------

sub _truncate_visual {
    my ($str, $maxlen) = @_;
    my $result = '';
    my $vlen   = 0;

    while ($str =~ /\G(&amp;(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);|.)/gs) {
        last if $vlen &gt;= $maxlen;
        $result .= $1;
        $vlen++;
    }
    return $result;
}


#------------------------------------------------------------------------
# eval_filter_factory                                   [% FILTER eval %]
#
# Create a filter to evaluate template text.
#------------------------------------------------------------------------

sub eval_filter_factory {
    my $context = shift;

    return sub {
        my $text = shift;
        $context-&gt;process(\$text);
    }
}


#------------------------------------------------------------------------
# perl_filter_factory                                   [% FILTER perl %]
#
# Create a filter to process Perl text iff the context EVAL_PERL flag
# is set.
#------------------------------------------------------------------------

sub perl_filter_factory {
    my $context = shift;
    my $stash = $context-&gt;stash;

    return (undef, Template::Exception-&gt;new('perl', 'EVAL_PERL is not set'))
        unless $context-&gt;eval_perl();

    return sub {
        my $text = shift;
        local($Template::Perl::context) = $context;
        local($Template::Perl::stash)   = $stash;
        my $out = eval &lt;&lt;EOF;
package Template::Perl;
\$stash = \$context-&gt;stash();
$text
EOF
        $context-&gt;throw($@) if $@;
        return $out;
    }
}


#------------------------------------------------------------------------
# redirect_filter_factory($context, $file)    [% FILTER redirect(file) %]
#
# Create a filter to redirect the block text to a file.
#------------------------------------------------------------------------

sub redirect_filter_factory {
    my ($context, $file, $options) = @_;
    my $outpath = $context-&gt;config-&gt;{ OUTPUT_PATH };

    return (undef, Template::Exception-&gt;new('redirect',
                                            'OUTPUT_PATH is not set'))
        unless $outpath;

    $context-&gt;throw('redirect', &quot;relative filenames are not supported: $file&quot;)
        if $file =~ m{(^|/)\.\./};

    $options = { binmode =&gt; $options } unless ref $options;

    sub {
        my $text = shift;
        my $outpath = $context-&gt;config-&gt;{ OUTPUT_PATH }
            || return '';
        $outpath .= &quot;/$file&quot;;
        my $error = Template::_output($outpath, \$text, $options);
        die Template::Exception-&gt;new('redirect', $error)
            if $error;
        return '';
    }
}


#------------------------------------------------------------------------
# stdout_filter_factory($context, $binmode)    [% FILTER stdout(binmode) %]
#
# Create a filter to print a block to stdout, with an optional binmode.
#------------------------------------------------------------------------

sub stdout_filter_factory {
    my ($context, $options) = @_;

    $options = { binmode =&gt; $options } unless ref $options;

    sub {
        my $text = shift;
        binmode(STDOUT) if $options-&gt;{ binmode };
        print STDOUT $text;
        return '';
    }
}


1;

__END__

=head1 NAME

Template::Filters - Post-processing filters for template blocks

=head1 SYNOPSIS

    use Template::Filters;

    $filters = Template::Filters-&gt;new(\%config);

    ($filter, $error) = $filters-&gt;fetch($name, \@args, $context);

    if ($filter) {
        print &amp;$filter(&quot;some text&quot;);
    }
    else {
        print &quot;Could not fetch $name filter: $error\n&quot;;
    }

=head1 DESCRIPTION

The C&lt;Template::Filters&gt; module implements a provider for creating subroutines
that implement the standard filters. Additional custom filters may be provided
via the L&lt;FILTERS&gt; configuration option.

=head1 METHODS

=head2 new(\%params)

Constructor method which instantiates and returns a reference to a
C&lt;Template::Filters&gt; object.  A reference to a hash array of configuration
items may be passed as a parameter.  These are described below.

    my $filters = Template::Filters-&gt;new({
        FILTERS =&gt; { ... },
    });

    my $template = Template-&gt;new({
        LOAD_FILTERS =&gt; [ $filters ],
    });

A default C&lt;Template::Filters&gt; module is created by the L&lt;Template&gt; module
if the L&lt;LOAD_FILTERS&gt; option isn't specified.  All configuration parameters
are forwarded to the constructor.

    $template = Template-&gt;new({
        FILTERS =&gt; { ... },
    });

=head2 fetch($name, \@args, $context)

Called to request that a filter of a given name be provided.  The name
of the filter should be specified as the first parameter.  This should
be one of the standard filters or one specified in the L&lt;FILTERS&gt;
configuration hash.  The second argument should be a reference to an
array containing configuration parameters for the filter.  This may be
specified as 0, or undef where no parameters are provided.  The third
argument should be a reference to the current L&lt;Template::Context&gt;
object.

The method returns a reference to a filter sub-routine on success.  It
may also return C&lt;(undef, STATUS_DECLINE)&gt; to decline the request, to allow
delegation onto other filter providers in the L&lt;LOAD_FILTERS&gt; chain of
responsibility.  On error, C&lt;($error, STATUS_ERROR)&gt; is returned where $error
is an error message or L&lt;Template::Exception&gt; object indicating the error
that occurred.

When the C&lt;TOLERANT&gt; option is set, errors are automatically downgraded to
a C&lt;STATUS_DECLINE&gt; response.

=head2 use_html_entities()

This class method can be called to configure the C&lt;html_entity&gt; filter to use
the L&lt;HTML::Entities&gt; module. An error will be raised if it is not installed
on your system.

    use Template::Filters;
    Template::Filters-&gt;use_html_entities();

=head2 use_apache_util()

This class method can be called to configure the C&lt;html_entity&gt; filter to use
the L&lt;Apache::Util&gt; module. An error will be raised if it is not installed on
your system.

    use Template::Filters;
    Template::Filters-&gt;use_apache_util();

=head2 use_rfc2732()

This class method can be called to configure the C&lt;uri&gt; and C&lt;url&gt; filters to
use the older RFC2732 standard for matching unsafe characters.

=head2 use_rfc3986()

This class method can be called to configure the C&lt;uri&gt; and C&lt;url&gt; filters to
use the newer RFC3986 standard for matching unsafe characters.

=head1 CONFIGURATION OPTIONS

The following list summarises the configuration options that can be provided
to the C&lt;Template::Filters&gt; L&lt;new()&gt; constructor. Please see
L&lt;Template::Manual::Config&gt; for further information about each option.

=head2 FILTERS

The L&lt;FILTERS|Template::Manual::Config#FILTERS&gt; option can be used to specify
custom filters which can then be used with the
L&lt;FILTER|Template::Manual::Directives#FILTER&gt; directive like any other. These
are added to the standard filters which are available by default.

    $filters = Template::Filters-&gt;new({
        FILTERS =&gt; {
            'sfilt1' =&gt;   \&amp;static_filter,
            'dfilt1' =&gt; [ \&amp;dynamic_filter_factory, 1 ],
        },
    });

=head2 TOLERANT

The L&lt;TOLERANT|Template::Manual::Config#TOLERANT&gt; flag can be set to indicate
that the C&lt;Template::Filters&gt; module should ignore any errors and instead
return C&lt;STATUS_DECLINED&gt;.

=head2 DEBUG

The L&lt;DEBUG|Template::Manual::Config#DEBUG&gt; option can be used to enable
debugging messages for the Template::Filters module by setting it to include
the C&lt;DEBUG_FILTERS&gt; value.

    use Template::Constants qw( :debug );

    my $template = Template-&gt;new({
        DEBUG =&gt; DEBUG_FILTERS | DEBUG_PLUGINS,
    });

=head1 STANDARD FILTERS

Please see L&lt;Template::Manual::Filters&gt; for a list of the filters provided
with the Template Toolkit, complete with examples of use.

=head1 AUTHOR

Andy Wardley E&lt;lt&gt;abw@wardley.orgE&lt;gt&gt; L&lt;http://wardley.org/&gt;

=head1 COPYRIGHT

Copyright (C) 1996-20202Andy Wardley.  All Rights Reserved.

This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=head1 SEE ALSO

L&lt;Template::Manual::Filters&gt;, L&lt;Template&gt;, L&lt;Template::Context&gt;

=cut

# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Flib64%2Fperl5%2FTemplate'>Back to Directory</a>