File Coverage

blib/lib/Test2/Compare/Object.pm

Criterion	Covered	Total	%
statement	84	84	100.0
branch	42	42	100.0
condition	10	12	83.3
subroutine	19	19	100.0
pod	9	10	90.0
total	164	167	98.2

package Test2::Compare::Object;
use strict;
use warnings;

use Test2::Util qw/try/;

use Test2::Compare::Meta();

use base 'Test2::Compare::Base';

our $VERSION = '0.000155';

use Test2::Util::HashBase qw/calls meta refcheck ending/;

use Carp qw/croak confess/;
use Scalar::Util qw/reftype blessed/;

sub init {
    my $self = shift;
    $self->{+CALLS} ||= [];
    $self->SUPER::init();
}

sub name { '' }

sub meta_class  { 'Test2::Compare::Meta' }
sub object_base { 'UNIVERSAL' }

sub verify {
    my $self = shift;
    my %params = @_;
    my ($got, $exists) = @params{qw/got exists/};

    return 0 unless $exists;
    return 0 unless defined $got;
    return 0 unless ref($got);
    return 0 unless blessed($got);
    return 0 unless $got->isa($self->object_base);
    return 1;
}

sub add_prop {
    my $self = shift;
    $self->{+META} = $self->meta_class->new unless defined $self->{+META};
    $self->{+META}->add_prop(@_);
}

sub add_field {
    my $self = shift;
    $self->{+REFCHECK} = Test2::Compare::Hash->new unless defined $self->{+REFCHECK};

    croak "Underlying reference does not have fields"
        unless $self->{+REFCHECK}->can('add_field');

    $self->{+REFCHECK}->add_field(@_);
}

sub add_item {
    my $self = shift;
    $self->{+REFCHECK} = Test2::Compare::Array->new unless defined $self->{+REFCHECK};

    croak "Underlying reference does not have items"
        unless $self->{+REFCHECK}->can('add_item');

    $self->{+REFCHECK}->add_item(@_);
}

sub add_call {
    my $self = shift;
    my ($meth, $check, $name, $context) = @_;
    $name ||= ref $meth eq 'ARRAY' ? $meth->[0]
        : ref $meth eq 'CODE' ? '\&CODE'
        : $meth;
    push @{$self->{+CALLS}} => [$meth, $check, $name, $context || 'scalar'];
}

sub deltas {
    my $self = shift;
    my %params = @_;
    my ($got, $convert, $seen) = @params{qw/got convert seen/};

    my @deltas;
    my $meta     = $self->{+META};
    my $refcheck = $self->{+REFCHECK};

    push @deltas => $meta->deltas(%params) if defined $meta;

    for my $call (@{$self->{+CALLS}}) {
        my ($meth, $check, $name, $context)= @$call;
        $context ||= 'scalar';

        $check = $convert->($check);

        my @args;
        if (ref($meth) eq 'ARRAY') {
            ($meth,@args) = @{$meth};
        }

        my $exists = ref($meth) || $got->can($meth);
        my $val;
        my ($ok, $err) = try {
            $val = $exists
                ? ( $context eq 'list' ? [ $got->$meth(@args) ] :
                    $context eq 'hash' ? { $got->$meth(@args) } :
                    $got->$meth(@args)
                )
                : undef;
        };

        if (!$ok) {
            push @deltas => $self->delta_class->new(
                verified  => undef,
                id        => [METHOD => $name],
                got       => undef,
                check     => $check,
                exception => $err,
            );
        }
        else {
            push @deltas => $check->run(
                id      => [METHOD => $name],
                convert => $convert,
                seen    => $seen,
                exists  => $exists,
                $exists ? (got => $val) : (),
            );
        }
    }

    return @deltas unless defined $refcheck;

    $refcheck->set_ending($self->{+ENDING});

    if ($refcheck->verify(%params)) {
        push @deltas => $refcheck->deltas(%params);
    }
    else {
        push @deltas => $self->delta_class->new(
            verified => undef,
            id       => [META => 'Object Ref'],
            got      => $got,
            check    => $refcheck,
        );
    }

    return @deltas;
}

1;

__END__