File Coverage

blib/lib/Test/Stream/Plugin/Grab.pm

Criterion	Covered	Total	%
statement	60	62	96.7
branch	3	8	37.5
condition	1	3	33.3
subroutine	15	15	100.0
pod	3	4	75.0
total	82	92	89.1

package Test::Stream::Plugin::Grab;
use strict;
use warnings;

use Test::Stream::Sync();
use Test::Stream::DebugInfo();
use Test::Stream::Hub::Interceptor();

use Test::Stream::Exporter qw/import default_export/;
default_export grab => sub { __PACKAGE__->new };
no Test::Stream::Exporter;

my $STACK = Test::Stream::Sync->stack;

use Test::Stream::HashBase(
    accessors => [qw/hub finished _events term_size/],
);

sub init {
    my $self = shift;

    my $ipc;
    if ($INC{'Test/Stream/IPC.pm'}) {
        my ($driver) = Test::Stream::IPC->drivers;
        $ipc = $driver->new;
    }

    $self->{+HUB} = Test::Stream::Hub::Interceptor->new(
        ipc => $ipc,
        no_ending => 1,
    );

    my @events;
    $self->{+HUB}->listen(sub { push @events => $_[1] });

    $self->{+_EVENTS} = \@events;

    $STACK->top(); # Make sure there is a top hub before we begin.
    $STACK->push($self->{+HUB});

    $self->{+TERM_SIZE} = $ENV{TS_TERM_SIZE};
    $ENV{TS_TERM_SIZE} = 80;
}

sub flush {
    my $self = shift;
    my $out = [@{$self->{+_EVENTS}}];
    @{$self->{+_EVENTS}} = ();
    return $out;
}

sub events {
    my $self = shift;
    # Copy
    return [@{$self->{+_EVENTS}}];
}

sub finish {
    my ($self) = @_; # Do not shift;
    $_[0] = undef;

    if (defined $self->{+TERM_SIZE}) {
        $ENV{TS_TERM_SIZE} = $self->{+TERM_SIZE};
    }
    else {
        delete $ENV{TS_TERM_SIZE};
    }

    my $hub = $self->{+HUB};

    $self->{+FINISHED} = 1;
    $STACK->pop($hub);

    my $dbg = Test::Stream::DebugInfo->new(
        frame => [caller(0)],
    );
    $hub->finalize($dbg, 1)
        if !$hub->no_ending
        && !$hub->state->ended;

    return $self->flush;
}

sub DESTROY {
    my $self = shift;
    return if $self->{+FINISHED};
    $STACK->pop($self->{+HUB});
}

1;

__END__