File Coverage

blib/lib/Test/Stream/Compare.pm

Criterion	Covered	Total	%
statement	92	94	97.8
branch	44	50	88.0
condition	20	26	76.9
subroutine	28	28	100.0
pod	8	12	66.6
total	192	210	91.4

package Test::Stream::Compare;
use strict;
use warnings;

use Test::Stream::Util qw/try sub_info/;
use Test::Stream::Delta;

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

use Test::Stream::Exporter;
export compare => sub {
    my ($got, $check, $convert) = @_;

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

    return $check->run(
        id      => undef,
        got     => $got,
        exists  => 1,
        convert => $convert,
        seen    => {},
    );
};

sub MAX_CYCLES() { 75 }

my @BUILD;

export get_build  => sub { @BUILD ? $BUILD[-1] : undef };
export push_build => sub { push @BUILD => $_[0] };

export pop_build => sub {
    return pop @BUILD if @BUILD && $_[0] && $BUILD[-1] == $_[0];
    my $have = @BUILD ? "$BUILD[-1]" : 'undef';
    my $want = $_[0]  ? "$_[0]"      : 'undef';
    croak "INTERNAL ERROR: Attempted to pop incorrect build, have $have, tried to pop $want";
};

export build => sub {
    my ($class, $code) = @_;

    my @caller = caller(1);

    die "'$caller[3]\()' should not be called in void context in $caller[1] line $caller[2]\n"
        unless defined(wantarray);

    my $build = $class->new(builder => $code, called => \@caller);

    push @BUILD => $build;
    my ($ok, $err) = try { $code->($build); 1 };
    pop @BUILD;
    die $err unless $ok;

    return $build;
};
no Test::Stream::Exporter;

use Test::Stream::HashBase(
    accessors => [qw/builder _file _lines _info called/]
);

*set_lines = \&set__lines;
*set_file  = \&set__file;

sub init {
    my $self = shift;
    $self->{_lines} = delete $self->{lines} if exists $self->{lines};
    $self->{_file}  = delete $self->{file}  if exists $self->{file};
}

sub file {
    my $self = shift;
    return $self->{+_FILE} if $self->{+_FILE};

    if ($self->{+BUILDER}) {
        $self->{+_INFO} ||= sub_info($self->{+BUILDER});
        return $self->{+_INFO}->{file};
    }
    elsif ($self->{+CALLED}) {
        return $self->{+CALLED}->[1];
    }

    return undef;
}

sub lines {
    my $self = shift;
    return $self->{+_LINES} if $self->{+_LINES};

    if ($self->{+BUILDER}) {
        $self->{+_INFO} ||= sub_info($self->{+BUILDER});
        return $self->{+_INFO}->{lines} if @{$self->{+_INFO}->{lines}};
    }
    if ($self->{+CALLED}) {
        return [$self->{+CALLED}->[2]];
    }
    return [];
}

use Test::Stream::Delta;
sub delta_class { 'Test::Stream::Delta' }

sub deltas { () }
sub got_lines { () }

sub stringify_got { 0 }

sub operator { '' }
sub verify   { confess "unimplemented" }
sub name     { confess "unimplemented" }

sub render {
    my $self = shift;
    return $self->name;
}

sub run {
    my $self = shift;
    my %params = @_;

    my $id      = $params{id};
    my $convert = $params{convert} or confess "no convert sub provided";
    my $seen    = $params{seen} ||= {};

    $params{exists} = exists $params{got} ? 1 : 0
        unless exists $params{exists};

    my $exists = $params{exists};
    my $got = $exists ? $params{got} : undef;

    # Prevent infinite cycles
    if ($got && ref $got) {
        die "Cycle detected in comparison, aborting"
            if $seen->{$got} && $seen->{$got} >= MAX_CYCLES;
        $seen->{$got}++;
    }

    my $ok = $self->verify(%params);
    my @deltas = $ok ? $self->deltas(%params) : ();

    $seen->{$got}-- if $got && ref $got;

    return if $ok && !@deltas;

    return $self->delta_class->new(
        verified => $ok,
        id       => $id,
        got      => $got,
        check    => $self,
        children => \@deltas,
        $exists ? () : (dne => 'got'),
    );
}

1;

__END__