In "Hello World":

use My::Wrapper qw( wrap );

wrap( \&hello_world );

sub hello_world {
    my %params = %{shift()};
    my $T_ref = $params{T};

    $T_ref->{msg} = "Hello World";

    return;
}
[download]

In "Foo Bar":

use My::Wrapper qw( wrap );

wrap( \&foo_bar );

sub foo_bar {
    my %params = %{shift()};
    my $T_ref = $params{T};

    $T_ref->{msg} = "Foo Bar";

    return;
}
[download]

Then the main module.

package My::Wrapper;

use strict;
use warnings;

use Exporter 'import';
@EXPORT_OK = qw( wrap );

use DBI;
use CGI;
use CGI::Carp qw(fatalsToBrowser warningsToBrowser);
use HTML::Template;
use HTML::Entities;

use lib 'code';
use config;

## Security
$CGI::DISABLE_UPLOADS = 1;    # no uploads!
$CGI::POST_MAX = 512*1024;    # max 512k post

sub wrap {
    my ( $code_ref ) = @_;

    my $template = templates::loadTemplate('template');
    my %T;
    my $innerTemplate;
    my $q = new CGI;
    my $c;

    $code_ref->({ q => $q,
                  T => \%T,
                  # etc.
                });

     ## Filling in the template here
    if($innerTemplate) {
    # load the template in, put it into %T.
    my $template = templates::loadTemplate('$innerTemplate');
    $template->param($T{innerContent}) if $T{innerContent};
    $T{content} = $template->output();
    }

    print $q->header();
    $template->param(%T);
    print $template->output();
}
[download]

I don't know anything about your template, and I'm not sure what I can deduce from what you've posted. If you want each script to have its own template, then you have to let the wrapped function give that back to the wrapper somehow. You could do this by having a special element in %T or have the wrapped code pass out a hash ref with whatever it wants to supply.

Also, it's important to note that the above code is not tested or anything. When I do this sort of thing myself, I use objects. In that case, I don't go passing things around; the object just sets its own attributes for communication.

Excellent advice and presentation++

Actually HTML::Template forces you to do such a 2-stage transformation.

If you want to avoid that, you could also use the HTML::Template-compatible HTML::Template::Compiled from tinita, which allows you to specify the innerContent by an additional TMPL-command, see HTC:INCLUDE

It will expand the embedded template(s) first and do the other template processing on the resulting joined template.

Not a big issue, but I like the feature.