File Coverage

blib/lib/Template/Overlay.pm

Criterion	Covered	Total	%
statement	80	82	97.5
branch	20	24	83.3
condition	9	12	75.0
subroutine	18	18	100.0
pod	2	2	100.0
total	129	138	93.4

use strict;
use warnings;

package Template::Overlay;
$Template::Overlay::VERSION = '1.13';
# ABSTRACT: A powerful, and simple, library for resolving placeholders in templated files
# PODNAME: Template::Resolver

use Carp;
use File::Copy qw(copy);
use File::Find;
use File::Path qw(make_path);
use File::Spec;
use File::stat;
use Fcntl;
use Log::Any;

my $logger = Log::Any->get_logger();

sub new {
    return bless( {}, shift )->_init(@_);
}

sub _init {
    my ( $self, $base, $resolver, %options ) = @_;

    $self->{base}     = File::Spec->rel2abs($base);
    $self->{resolver} = $resolver;
    $self->{key}      = $options{key};

    $logger->debug( 'new overlay [', $self->{base}, ']' );

    return $self;
}

sub _overlay_files {
    my ( $self, $overlays ) = @_;

    my %overlay_files = ();
    foreach my $overlay ( ref($overlays) eq 'ARRAY' ? @$overlays : ($overlays) ) {
        $overlay = File::Spec->rel2abs($overlay);
        my $base_path_length = length($overlay);
        find(
            sub {
                if ( -f $File::Find::name && $_ !~ /~$/ && $_ !~ /^\..+\.swp$/ ) {
                    my $relative = _relative_path( $File::Find::name, $base_path_length );
                    $overlay_files{$relative} = $File::Find::name;
                }
            },
            $overlay
        );
    }

    return %overlay_files;
}

sub overlay {
    my ( $self, $overlays, %options ) = @_;

    my %overlay_files = $self->_overlay_files($overlays);
    my $destination   = $self->{base};
    if ( $options{to} && $options{to} ne $self->{base} ) {
        $destination = File::Spec->rel2abs( $options{to} );
        my $base_path_length = length( File::Spec->rel2abs( $self->{base} ) );
        find(
            sub {
                my $relative = _relative_path( $File::Find::name, $base_path_length );
                if ( -d $File::Find::name ) {
                    make_path( File::Spec->catdir( $destination, $relative ) );
                }
                if ( -f $File::Find::name ) {
                    my $template = delete( $overlay_files{$relative} );
                    my $file = File::Spec->catfile( $destination, $relative );
                    if ($template) {
                        $self->_resolve( $template, $file, $options{resolver} );
                    }
                    else {
                        copy( $_, $file );
                    }
                }
            },
            $self->{base}
        );
    }
    foreach my $relative ( keys(%overlay_files) ) {
        my $file = File::Spec->catfile( $destination, $relative );
        make_path( ( File::Spec->splitpath($file) )[1] );
        $self->_resolve( $overlay_files{$relative}, $file, $options{resolver} );
    }
}

sub _relative_path {
    my ( $path, $base_path_length ) = @_;
    return
        length($path) == $base_path_length
        ? ''
        : substr( $File::Find::name, $base_path_length + 1 );
}

sub _resolve {
    my ( $self, $template, $file, $resolver ) = @_;

    return if ( $resolver && &$resolver( $template, $file ) );

    if ( -f $file ) {
        $logger->debugf(
            '[%s] already exists, deleting to ensure creation with proper permissions', $file );
        unlink($file);
    }

    my $mode = stat($template)->mode() & 07777;    ## no critic
    $logger->infof( 'processing [%s] -> [%04o] [%s]', $template, $mode, $file );
    sysopen( my $handle, $file, O_CREAT | O_TRUNC | O_WRONLY, $mode )
        || croak("open $file failed: $!");
    eval {
        print( $handle $self->{resolver}->resolve(
                filename => $template,
                ( $self->{key} ? ( key => $self->{key} ) : () )
            )
        );
    };
    my $error = $@;
    close($handle);
    croak($error) if ($error);
}

1;

__END__