File Coverage

blib/lib/Input/Validator/Condition.pm

Criterion	Covered	Total	%
statement	54	55	98.1
branch	14	14	100.0
condition	5	7	71.4
subroutine	12	13	92.3
pod	6	8	75.0
total	91	97	93.8

package Input::Validator::Condition;

use strict;
use warnings;

use base 'Input::Validator::Base';

use Input::Validator::ConstraintBuilder;

sub BUILD {
    my $self = shift;

    $self->{then} ||= sub { };
    $self->{bulks} ||= [];

    return $self;
}

sub regexp { shift->constraint('regexp' => @_) }
sub length { shift->constraint('length' => @_) }

sub when {
    my $self = shift;
    my $fields = ref $_[0] eq 'ARRAY' ? shift : [@_];

    my $bulk = {fields => $fields, constraints => []};
    push @{$self->{bulks}}, $bulk;

    return $self;
}

sub then {
    my $self = shift;

    return $self->{then} unless @_;

    $self->{then} = $_[0];

    return $self;
}

sub constraint {
    my $self = shift;

    my $constraint = Input::Validator::ConstraintBuilder->build(@_);

    my $bulk = $self->{bulks}->[-1];
    push @{$bulk->{constraints}}, $constraint;

    return $self;
}

sub is_matched { shift->{matched} }

sub match {
    my $self   = shift;
    my $params = shift;

    foreach my $bulk (@{$self->{bulks}}) {
        foreach my $name (@{$bulk->{fields}}) {
            my $field = $params->{$name};

            # No field
            return 0 unless $field;

            # Field has already an error
            return 0 if $field->error;

            my $values = $field->value;
            $values = [$values] unless ref($values) eq 'ARRAY';

            foreach my $value (@$values) {
                return 0 unless defined($value) && $value ne '';

                foreach my $c (@{$bulk->{constraints}}) {
                    my ($ok, $error) = $c->is_valid($value);
                    return 0 unless $ok;
                }
            }
        }
    }

    $self->{matched} = 1;

    return 1;
}

1;
__END__