File Coverage

blib/lib/Text/Template/LocalVars.pm

Criterion	Covered	Total	%
statement	47	56	83.9
branch	11	20	55.0
condition	7	17	41.1
subroutine	8	9	88.8
pod	3	3	100.0
total	76	105	72.3

package Text::Template::LocalVars;

use 5.008009;
use strict;
use warnings;

use parent 'Text::Template';
use Text::Template::LocalVars::Package;

our @EXPORT_OK = qw(fill_in_file fill_in_string TTerror);

our $VERSION = '0.04';

#################################################################

# These are used to pass the name of the variable package to a nested
# fill. The fragment code may run code compiled into *another* package,
# and if that code wants to perform a localized fill using the
# fragment's variable package, it has no easy way of finding out.
# This package variable is localized to the correct package name just
# prior to calling SUPER::fill_in

our $TemplatePackage;
our $TemplateParentPackage;

our $TrackParentDefault = 1;

#################################################################
# match public API (and some private ones too)

*_param = \&Text::Template::_param;

*TTerror = \&Text::Template::TTerror;

*ERROR = \$Text::Template::ERROR;

sub fill_in_string {
    my $string = shift;
    my $package = _param( 'package', @_ );

    # pull in the correct package if we're tracking parent
    # packages. note that we retain Text::Template's behavior of
    # always assigning a package ( RT#51473 ).  this behavior is most
    # likely because otherwise if the package parameter is not
    # specified the call to fill_this_in() will always use *this*
    # package to store its values, rather than the original caller's
    # package.

    my $trackvarpkg = _param( 'trackvarpkg', @_ );
    $trackvarpkg = $TrackParentDefault unless defined $trackvarpkg;

    if ( !defined $package ) {
        push @_,
          'package' => (
              $trackvarpkg && defined $TemplatePackage
            ? $TemplatePackage
            : scalar( caller ) );
    }
    __PACKAGE__->fill_this_in( $string, @_ );
}

sub fill_in_file {
    my $fn = shift;

    my $package = _param( 'package', @_ );

    # pull in the correct package if we're localizing and tracking
    # parent packages.

    my $trackvarpkg = _param( 'trackvarpkg', @_ );
    $trackvarpkg = $TrackParentDefault unless defined $trackvarpkg;

    push @_, $TemplatePackage
      if !defined $package
      && $trackvarpkg
      && defined $TemplatePackage;

    my $templ = __PACKAGE__->new( TYPE => 'FILE', SOURCE => $fn, @_ )
      or return undef;
    $templ->compile or return undef;
    my $text = $templ->fill_in( @_ );
    $text;
}


# delete a parameter from a passed set and return the key that was
# used to specify it.
sub _del_param {

    my $kk;
    my ( $k, $h ) = @_;

    my $first;

    # delete *all* keys that would match, just to be safe.
    my @keys = grep { exists $h->{$_} } $k, "\u$k", "\U$k", "-$k", "-\u$k",
      "-\U$k";

    delete @{$h}{@keys};

    return $keys[0];
}


sub fill_in {

    my $self = shift;
    my %args = @_;

    my $trackvarpkg = _param( 'trackvarpkg', %args );
    $trackvarpkg = $TrackParentDefault unless defined $trackvarpkg;

    my $localize = _param( 'localize', %args );

    if ( $localize ) {

        my $pkg
          = _param( 'package', %args )
          || ( $trackvarpkg ? $TemplatePackage : () )
          || scalar( caller );

        my $npkg = Text::Template::LocalVars::Package->new( $pkg );
        $args{ _del_param( 'package', \%args ) || 'package' } = $npkg->pkg;
        _del_param( 'localize', \%args );

        local $TemplateParentPackage = $pkg;
        local $TemplatePackage       = $npkg->pkg;

        $self->SUPER::fill_in( %args );

    }

    else {

        # track the template variable package even if not localizing,
        # in case a fragment calls fill_in and wants to localize
        # and track the parent.  yes, we are our own parent.

        my $parent
          = _param( 'package', %args )
          || ( $trackvarpkg ? $TemplatePackage : () )
          || scalar( caller );

        local $TemplateParentPackage = $parent;
        local $TemplatePackage       = $parent;

	# if no package was specified, and we're requested to track the parent,
	# use that as the package
	$args{ _del_param( 'package', \%args ) || 'package' } = $parent
	    if $trackvarpkg;

        $self->SUPER::fill_in( %args );

    }

}

1;

__END__