File Coverage

blib/lib/Class/AlzaboWrapper/Cursor.pm

Criterion	Covered	Total	%
statement	9	41	21.9
branch	0	18	0.0
condition			n/a
subroutine	3	9	33.3
pod	5	5	100.0
total	17	73	23.2

package Class::AlzaboWrapper::Cursor;

use strict;

use Class::AlzaboWrapper;

use Params::Validate qw( validate_with SCALAR ARRAYREF );
Params::Validate::validation_options
    ( on_fail =>
      sub { Class::AlzaboWrapper::Exception::Params->throw
                ( message => join '', @_ ) } );

sub new
{
    my $class = shift;

    my %p = validate_with( params => \@_,
                           spec =>
                           { cursor => { can => 'next' },
                             args   => { type => ARRAYREF, default => [] },
                             constructor_method => { type => SCALAR, default => 'new' },
                           },
                           allow_extra => 1,
                         );

    my $self = bless { %p,
                     }, $class;

    return $self;
}

sub _new_from_row
{
    my $self = shift;
    my $row = shift;

    return undef unless defined $row;
    return $row if $row->isa( 'Class::AlzaboWrapper' );

    my $class = Class::AlzaboWrapper->TableToClass( $row->table );
    Class::AlzaboWrapper::Exception->throw
        ( error => "Cannot find a class for " . $row->table->name . " table" )
            unless $class;

    my $meth = $self->{constructor_method};

    return
        $class->$meth
            ( object => $row,
              @{ $self->{args} },
            );
}

sub next
{
    my $self = shift;

    my @things;
    if (wantarray)
    {
        @things = $self->{cursor}->next
            or return;
    }
    else
    {
        $things[0] = $self->{cursor}->next
            or return;
    }

    my @r = map { $self->_new_from_row($_) } @things;

    return wantarray ? @r : $r[0];
}

sub next_as_hash
{
    my $self = shift;

    my %hash = $self->{cursor}->next_as_hash or return;
    map { $hash{$_} = $self->_new_from_row($hash{$_}) } keys %hash;

    return %hash;
}

sub all
{
    my $self = shift;

    my @all;
    while ( my @a = $self->next )
    {
        push @all, @a == 1 ? $a[0] : \@a;
    }

    return @all;
}

sub count { $_[0]->{cursor}->count }


1;

__END__