File Coverage

blib/lib/Data/Validator/Recursive.pm

Criterion	Covered	Total	%
statement	89	90	98.8
branch	40	46	86.9
condition	3	5	60.0
subroutine	13	13	100.0
pod	7	7	100.0
total	152	161	94.4

package Data::Validator::Recursive;

use strict;
use warnings;
use 5.008_001;
our $VERSION = '0.07';

use Carp 'croak';
use Data::Validator;

sub new {
    my ($class, @args) = @_;
    croak "Usage: Data::Validator::Recursive->new(\$arg_name => \$rule [, ... ])" unless @args;

    my $self = bless {
        validator         => undef,
        nested_validators => [],
        error             => undef,
    }, ref $class || $class;

    $self->_build_rules(@args);
    return $self;
}

sub _build_rules {
    my ($self, @args) = @_;

    for (my ($i, $l) = (0, scalar @args); $i < $l; $i += 2) {
        my ($name, $rule) = @args[$i, $i+1];
        $rule = { isa => $rule } unless ref $rule eq 'HASH';

        if (my $nested_rule = delete $rule->{rule}) {
            if (ref $nested_rule eq 'HASH') {
                $nested_rule = [ %$nested_rule ];
            }
            elsif (ref $nested_rule ne 'ARRAY') {
                croak "$name.rule must be ARRAY or HASH";
            }

            $rule->{isa} ||= 'HashRef';
            my $with = delete $rule->{with};
            my $validator = $self->new(@$nested_rule);
            if ($with) {
                $with = [ $with ] unless ref $with eq 'ARRAY';
                $validator->with(@$with);
            }

            push @{ $self->{nested_validators} }, {
                name      => $name,
                validator => $validator,
            };
        }
    }

    $self->{validator} = Data::Validator->new(@args)->with('NoThrow');
}

sub with {
    my ($self, @extentions) = @_;
    $self->{validator}->with(@extentions);
    return $self;
}

sub validate {
    my ($self, $params, $_parent_name) = @_;
    $self->{errors} = undef;

    my ($result) = $self->{validator}->validate($params);
    if (my $errors = $self->{validator}->clear_errors) {
        $self->{errors} = [
            map {
                my $name = $_parent_name ? "$_parent_name.$_->{name}" : $_->{name};
                my $type = $_->{type};
                my ($message, $other_name);
                if ($type eq 'ExclusiveParameter') {
                    $other_name = $_parent_name
                        ? "$_parent_name.$_->{conflict}" : $_->{conflict};
                    $message = sprintf q{'%s' and '%s' is %s}, $name, $other_name, $type;
                }
                elsif ($type eq 'InvalidValue') {
                    my $org_message = (split ': ', $_->{message}, 2)[1];
                    $message = sprintf q{Invalid value for '%s': %s}, $name, $org_message;
                }
                elsif ($type eq 'MissingParameter') {
                    my $org_message = (split ': ', $_->{message}, 2)[1];
                    $org_message =~ s/'([^']+)'/'$_parent_name.$1'/g if $_parent_name;
                    $message = sprintf q{Missing parameter: %s}, $org_message;
                }
                else {
                    $message = sprintf q{'%s' is %s}, $name, $type;
                }

                +{
                    type    => $type,
                    name    => $name,
                    message => $message,
                    defined $other_name ? (conflict => $other_name) : (),
                };
            } @$errors
        ];
        return;
    }

    for my $rule (@{ $self->{nested_validators} }) {
        my $name = $rule->{name};
        next unless exists $result->{$name};

        my $validator = $rule->{validator};

        my $result_in_nested;
        if (ref $result->{$name} eq 'ARRAY') {
            $result_in_nested = [];
            my $i = 0;
            for my $child_params (@{ $result->{$name} }) {
                my $indexed_name = sprintf('%s[%d]', $name, $i++);
                my ($child_result) = $validator->validate($child_params, $_parent_name ? "$_parent_name.$indexed_name" : $indexed_name);
                if (my $errors = $validator->errors) {
                    $self->{errors} = $errors;
                    return;
                }
                push @$result_in_nested, $child_result;
            }
        }
        else {
            ($result_in_nested) = $validator->validate($result->{$name}, $_parent_name ? "$_parent_name.$name" : $name);
        }

        if (my $errors = $validator->errors) {
            $self->{errors} = $errors;
            return;
        } else {
            $result->{$name} = $result_in_nested;
        }
    }

    return $result;
}

sub error {
    my $self = shift;
    my $errors = $self->errors or return;
    $errors->[0];
}

sub errors {
    my $self = shift;
    $self->{errors};
}

sub has_errors {
    my $self = shift;
    $self->{errors} ? 1 : 0;
}
*has_error = *has_errors; # backward compatible

sub clear_errors {
    my $self = shift;
    delete $self->{errors};
}

1;
__END__