File Coverage

blib/lib/Footprintless/Overlay.pm

Criterion	Covered	Total	%
statement	110	110	100.0
branch	22	32	68.7
condition	1	2	50.0
subroutine	28	28	100.0
pod	3	3	100.0
total	164	175	93.7

use strict;
use warnings;

package Footprintless::Overlay;
$Footprintless::Overlay::VERSION = '1.29';
# ABSTRACT: An overlay manager
# PODNAME: Footprintless::Overlay

use parent qw(Footprintless::MixableBase);

use Carp;
use Footprintless::Mixins qw (
    _clean
    _command_options
    _entity
    _extract_resource
    _local_template
    _push_to_destination
    _sub_coordinate
    _sub_entity
);
use Footprintless::Util qw(
    dynamic_module_new
    invalid_entity
    temp_dir
);
use Log::Any;
use File::Find;
use File::Spec;
use Template::Resolver;
use Template::Overlay;

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

sub clean {
    my ($self) = @_;
    $self->_clean();
}

sub _dirs_template {
    my ( $self, $to_dir, $with_dirs_work ) = @_;

    my $base_dir     = $self->_sub_entity('base_dir');
    my $template_dir = $self->_sub_entity('template_dir');

    my $unpack_dir;
    my $resource = $self->_sub_entity('resource');
    if ($resource) {
        $unpack_dir = temp_dir();
        $self->_extract_resource( $resource, $unpack_dir );

        if ($base_dir) {
            $base_dir = File::Spec->catdir( $unpack_dir, $base_dir );
        }
        if ($template_dir) {
            $template_dir =
                ref($template_dir) eq 'ARRAY'
                ? [ map { File::Spec->catdir( $unpack_dir, $_ ) } @$template_dir ]
                : File::Spec->catdir( $unpack_dir, $template_dir );
        }
    }

    &$with_dirs_work( $base_dir, $template_dir, $to_dir );
}

sub _dot_footprintless_resolver {
    my ($self) = @_;
    return sub {
        my ( $template, $destination ) = @_;
        if ( $template =~ /\/\.footprintless$/ ) {
            $self->_resolve_footprintless( $template, $destination );
            return 1;
        }
        return 0;
    };
}

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

    $self->clean();

    if ( $options{to_dir} ) {
        $self->_dirs_template(
            $options{to_dir},
            sub {
                $self->_initialize(@_);
            }
        );
    }
    else {
        $self->_local_with_dirs_template(
            sub {
                $self->_initialize(@_);
            }
        );
    }
}

sub _initialize {
    my ( $self, $base_dir, $template_dir, $to_dir ) = @_;
    $self->_overlay($base_dir)->overlay(
        $template_dir,
        resolver => $self->_dot_footprintless_resolver(),
        to       => $to_dir
    );
}

sub _local_with_dirs_template {
    my ( $self, $local_work ) = @_;
    $self->_local_template(
        sub {
            $self->_dirs_template( $_[0], $local_work );
        }
    );
}

sub _overlay {
    my ( $self, $base_dir ) = @_;

    my @overlay_opts = ();
    my $key          = $self->_sub_entity('key');
    push( @overlay_opts, key => $key ) if ($key);

    return Template::Overlay->new( $base_dir, $self->_resolver(), @overlay_opts );
}

sub _resolver {
    my ($self) = @_;

    my @resolver_opts = ();
    my $os            = $self->_sub_entity('os');
    push( @resolver_opts, os => $os ) if ($os);

    my $resolver_coordinate = $self->_sub_entity('resolver_coordinate');
    my $resolver_spec =
          $resolver_coordinate
        ? $self->_entity($resolver_coordinate)
        : $self->_entity();

    my $resolver;
    my $resolver_factory = $self->_entity('footprintless.overlay.resolver_factory');
    if ($resolver_factory) {
        $logger->tracef( "using resolver_factory: %s", $resolver_factory );
        $resolver =
            dynamic_module_new($resolver_factory)->new_resolver( $resolver_spec, @resolver_opts );
    }
    else {
        $resolver = Template::Resolver->new( $resolver_spec, @resolver_opts );
    }
    return $resolver;
}

sub _resolve_footprintless {
    my ( $self, $template, $footprintless_path ) = @_;
    my $destination = ( File::Spec->splitpath($footprintless_path) )[1];
    $logger->debugf( "resolving [%s]->[%s]", $template, $destination );

    my $spec = do($template) || return;
    croak("invalid $template") unless ( ref($spec) eq 'HASH' );

    if ( $spec->{clean} ) {
        my @to_be_cleaned =
            map { File::Spec->catdir( $destination, $_ ) . ( /\/$/ ? '/' : '' ); }
            ref( $spec->{clean} ) ? @{ $spec->{clean} } : ( $spec->{clean} );

        Footprintless::Util::clean(
            \@to_be_cleaned,
            command_runner  => $self->{factory}->command_runner(),
            command_options => $self->_command_options()
        );
    }

    if ( $spec->{resources} ) {
        my $resource_manager = $self->{factory}->resource_manager();
        foreach my $resource ( keys( %{ $spec->{resources} } ) ) {
            $resource_manager->download( $spec->{resources}{$resource}, to => $destination );
        }
    }
}

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

    if ( $options{to_dir} ) {
        $self->_dirs_template(
            $options{to_dir},
            sub {
                $self->_update(@_);
            }
        );
    }
    else {
        $self->_local_with_dirs_template(
            sub {
                $self->_update(@_);
            }
        );
    }
}

sub _update {
    my ( $self, $base_dir, $template_dir, $to_dir ) = @_;
    $logger->tracef( "update to=[%s], template=[%s]", $to_dir, $template_dir );
    $self->_overlay($to_dir)
        ->overlay( $template_dir, resolver => $self->_dot_footprintless_resolver() );
}

1;

__END__