File Coverage

blib/lib/JIP/Spy/Events.pm

Criterion	Covered	Total	%
statement	94	99	94.9
branch	21	22	95.4
condition	4	4	100.0
subroutine	24	27	88.8
pod	8	13	61.5
total	151	165	91.5

package JIP::Spy::Events;

use strict;
use warnings;
use version 0.77;

use Carp qw(croak);
use Scalar::Util qw(blessed reftype);
use English qw(-no_match_vars);

use JIP::Spy::Event;

our $VERSION = version->declare('v0.0.4');
our $AUTOLOAD;

sub new {
    my ( $class, %param ) = @ARG;

    my $state = {
        on_spy_event => {},
        events       => [],
        times        => {},
        skip_methods => {},
        want_array   => 0,
    };

    if ( $param{want_array} ) {
        $state->{want_array} = 1;
    }

    if ( my $skip_methods = $param{skip_methods} ) {
        foreach my $method_name ( @{$skip_methods} ) {
            $state->{skip_methods}->{$method_name} = undef;
        }
    }

    return bless $state, $class;
} ## end sub new

sub events {
    my ($self) = @ARG;

    return $self->{events};
}

sub times {
    my ($self) = @ARG;

    return $self->{times};
}

sub want_array {
    my ($self) = @ARG;

    return $self->{want_array};
}

sub skip_methods {
    my ($self) = @ARG;

    return $self->{skip_methods};
}

sub clear {
    my ($self) = @ARG;

    @{ $self->events() } = ();
    %{ $self->times() }  = ();

    return $self;
}

sub on_spy_event {
    my ( $self, %declarations ) = @ARG;

    if (%declarations) {
        $self->{on_spy_event} = \%declarations;
    }

    return $self->{on_spy_event};
}

sub called {
    my ($self) = @ARG;

    return 1 if keys %{ $self->times() };
    return 0;
}

sub not_called {
    my ($self) = @ARG;

    return 1 if !$self->called();
    return 0;
}

sub AUTOLOAD {
    my ( $self, @arguments ) = @ARG;

    if ( !blessed $self ) {
        croak q{Can't call "AUTOLOAD" as a class method};
    }

    my ($method_name) = $AUTOLOAD =~ m{^ .+ :: ([^:]+) $}x;

    undef $AUTOLOAD;

    return $self->_handle_event(
        method_name => $method_name,
        arguments   => \@arguments,
        want_array  => wantarray,
    );
}

sub isa {
    no warnings 'misc';
    goto &UNIVERSAL::isa;
}

sub can {
    my ( $self, $method_name ) = @ARG;

    if ( blessed $self ) {
        no warnings 'misc';
        goto &UNIVERSAL::can;
    }
    else {
        my $code;
        no warnings 'misc';
        $code = UNIVERSAL::can( $self, $method_name );

        return $code;
    }
}

sub DOES {
    # DOES is equivalent to isa by default
    goto &isa;
}

sub VERSION {
    no warnings 'misc';
    goto &UNIVERSAL::VERSION;
}

sub DESTROY { }

sub _handle_event {
    my ( $self, %param ) = @ARG;

    return $self if exists $self->skip_methods()->{ $param{method_name} };

    {
        my %event = (
            method    => $param{method_name},
            arguments => $param{arguments},
        );

        if ( $self->want_array() ) {
            $event{want_array} = $param{want_array};
        }

        push @{ $self->events() }, \%event;
    }

    my $times = $self->times()->{ $param{method_name} } // 0;
    $times += 1;
    $self->times()->{ $param{method_name} } = $times;

    my $on_spy_event = $self->on_spy_event()->{ $param{method_name} };

    return $self if !$on_spy_event;

    if ( ( reftype($on_spy_event) || q{} ) ne 'CODE' ) {
        croak sprintf(
            q{"%s" is not a callback},
            $param{method_name},
        );
    }

    my $event = JIP::Spy::Event->new(
        method     => $param{method_name},
        arguments  => $param{arguments},
        want_array => $param{want_array},
        times      => $times,
    );

    return $on_spy_event->( $self, $event );
} ## end sub _handle_event

1;

__END__