Text::MicroMason::PostProcess - Apply Filters to All Template Output

       This mixin class adds filtering of all template output to any MicroMason class.

       Filter functions can accept the string to be output and return a filtered version:

         $mason->post_process( sub {
           my $foo = shift;
           $foo =~ s/a-Z/A-Z/;
           return $foo;
         } );

       If a filter function has an empty prototype, it's assumed to work on $_:

         $mason->post_process( sub () {
           s/a-Z/A-Z/
         } );

   PublicMethodspost_processors()
           Gets and sets the functions to be used for output filtering.

           Called with no arguments, returns the list of filter functions:

             my @functions = $mason->post_processors();

           Called with one array-ref argument, sets the list of filter functions:

             $mason->post_processors( \@functions );

           Called with one or more function-ref arguments, appends to the list:

             $mason->post_processors( $filter1, $filter2 );

   SupportedAttributes
       post_process
           Stores a reference to a function or an array of functions to be used:

             $mason->{post_process} = $function;
             $mason->{post_process} = [ $function1, $function2 ];

           You  can set this attribute when you create your mason object, or in calls to the compile and execute
           methods.

   PrivateMethodspost_process()
             $mason->post_process( $output ) : $filtered_output

           Applies the post-processing filter.

       Text::MicroMason::PostProcess - Apply Filters to All Template Output

       For an overview of this templating framework, see Text::MicroMason.

       This is a mixin class intended for use with Text::MicroMason::Base.

       For    distribution,    installation,    support,    copyright    and    license     information,     see
       Text::MicroMason::Docs::ReadMe.

perl v5.36.0                                       2023-08-10                 Text::MicroMason::PostProcess(3pm)

       Instead of using this class directly, pass its name to be mixed in:

           use Text::MicroMason;
           my $mason = Text::MicroMason->new( -PostProcess );

       Use the standard compile and execute methods to parse and evaluate templates:

         print $mason->compile( text=>$template )->( @%args );
         print $mason->execute( text=>$template, @args );

       You can define output filters at creation or subsequently:

           $mason = Text::MicroMason->new( -PostProcess, post_process => $func );

           $mason->post_processors( $func );

           $mason->compile( text => $template, post_process => $func );

           $mason->execute( text => $template, { post_process => $func }, @args );