File Coverage

blib/lib/App/PerlWatcher/Engine.pm

Criterion	Covered	Total	%
statement	96	96	100.0
branch	6	6	100.0
condition			n/a
subroutine	23	23	100.0
pod	3	4	75.0
total	128	129	99.2

package App::PerlWatcher::Engine;
{
  $App::PerlWatcher::Engine::VERSION = '0.20';
}
# ABSTRACT: Creates Watchers and lets them  notify Frontend with their's Statuses

use 5.12.0;
use strict;
use warnings;

use AnyEvent;
use Carp;
use Class::Load ':all';
use Smart::Comments -ENV;
use File::Spec;
use List::MoreUtils qw/first_index/;
use Moo;
use Path::Tiny;

use App::PerlWatcher::Shelf;
use App::PerlWatcher::Util::Bootstrap qw/get_home_dir/;
use App::PerlWatcher::Util::Storable qw/freeze thaw/;





has 'frontend'          => ( is => 'rw');


has 'config'            => ( is => 'ro', required => 0);

has 'backend'           => ( is => 'ro', required => 1);


has 'statuses_file'     => ( is => 'ro', default => sub {
        return path(File::Spec->catfile(get_home_dir(), "statuses-shelf.data"));
    });


has 'watchers'          => ( is => 'lazy');


has 'polling_watchers' => ( is => 'ro', default => sub{ [] });


has 'watchers_order'    => ( is => 'lazy');


has 'shelf'             => ( is => 'rw');

sub _build_watchers {
    my $self = shift;
    my $config = $self->config;
    my @r;
    my $poll_callback = sub {
        my $w = shift;
        push @{ $self->polling_watchers }, $w;
        $self->frontend->poll($w);
    };
    my $engine_callback = sub {
        my $status = shift;
        my $w_idx = first_index { $_->unique_id eq $status->watcher->unique_id }
            @{ $self->polling_watchers };
        splice( @{ $self->polling_watchers }, $w_idx, 1);
        AnyEvent::postpone {
            $self->frontend->update($status);
        };
    };
    for my $watcher_definition ( @{ $config -> {watchers} } ) {
        my ($class, $watcher_config )
            = @{ $watcher_definition }{ qw/class config/ };
        my $watcher;
        eval {
            load_class($class);
            $watcher = $class->new(
                engine_config => $config,
                callback      => $engine_callback,
                poll_callback => $poll_callback,
                %$watcher_config
            );
            $watcher->callback($engine_callback);
            push @r, $watcher;
        };
        carp "Error creating watcher $class : $@" if $@;
    }
    return \@r;
}

sub _build_watchers_order {
    my $self = shift;
    my $watchers = $self->watchers;
    my $order = {};
    $order->{ $watchers->[$_] } = $_ for 0 .. @$watchers - 1;
    return $order;
}

sub _build_shelf {
    my $self = shift;
    my $statuses_file = $self->statuses_file;
    if ( -r $statuses_file ) {
        my $data = $statuses_file->slurp;
        thaw($self, $data)
            and return $self->shelf;
    }
    return App::PerlWatcher::Shelf->new;
}

sub BUILD {
    my $self = shift;
    $self->shelf($self->_build_shelf);
}


sub start {
    my $self = shift;
    $_->start for ( @{ $self->watchers } );
    # actually trigger watchers
    $self->backend->start_loop;
}


sub stop {
    my $self = shift;
    $self->backend->stop_loop;

    my $data = freeze($self);
    $self->statuses_file->spew($data);
}


sub sort_statuses {
    my ($self, $statuses) = @_;
    my $order_of = $self->watchers_order;
    return [
        sort {
            $order_of->{ $a->watcher } <=> $order_of->{ $b->watcher };
        } @$statuses
    ];
}


1;

__END__