File Coverage

blib/lib/Input/Validator.pm

Criterion	Covered	Total	%
statement	131	134	97.7
branch	32	42	76.1
condition	17	22	77.2
subroutine	23	26	88.4
pod	14	15	93.3
total	217	239	90.7

package Input::Validator;

use strict;
use warnings;

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

our $VERSION = '0.001005';

use Input::Validator::Bulk;
use Input::Validator::Condition;
use Input::Validator::Field;
use Input::Validator::Group;

require Carp;

sub BUILD {
    my $self = shift;

    $self->{fields}     = {};
    $self->{conditions} = [];
    $self->{groups}     = [];
    $self->{messages} ||= {};

    $self->{trim} = 1 unless defined $self->{trim};

    $self->{explicit} ||= 0;

    return $self;
}

sub messages { @_ > 1 ? $_[0]->{messages} = $_[1] : $_[0]->{messages} }
sub trim     { @_ > 1 ? $_[0]->{trim}     = $_[1] : $_[0]->{trim} }
sub explicit { @_ > 1 ? $_[0]->{explicit} = $_[1] : $_[0]->{explicit} }

sub field {
    my $self = shift;

    # Return field if it is already created
    return $self->{fields}->{$_[0]}
      if @_ == 1 && ref($_[0]) ne 'ARRAY' && $self->{fields}->{$_[0]};

    # Accept array or arrayref
    my @names = @_ == 1 && ref($_[0]) eq 'ARRAY' ? @{$_[0]} : @_;

    my $fields = [];
    foreach my $name (@names) {
        my $field = Input::Validator::Field->new(
            name     => $name,
            messages => $self->{messages},
            explicit => $self->{explicit},
        );

        $self->{fields}->{$name} = $field;
        push @$fields, $field;
    }

    return $self->{fields}->{$names[0]} if @names == 1;

    return Input::Validator::Bulk->new(fields => $fields);
}

sub when {
    my $self = shift;

    my $cond = Input::Validator::Condition->new->when(@_);

    push @{$self->{conditions}}, $cond;

    return $cond;
}

sub group {
    my $self   = shift;
    my $name   = shift;
    my $fields = shift;

    if (my ($exists) = grep { $_->name eq $name } @{$self->{groups}}) {
        Carp::croak("Fields of group '$name' already defined.") if $fields;
        return $exists;
    }

    $fields = [map { $self->{fields}->{$_} } @$fields];

    my $group = Input::Validator::Group->new(name => $name, fields => $fields);
    push @{$self->{groups}}, $group;

    return $group;
}

sub has_unknown_params {
    my $self = shift;

    return $self->{has_unknown_params};
}

sub has_errors {
    my $self = shift;

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

    return 1 if $errors && scalar keys %$errors;

    return 0;
}

sub error {
    my $self = shift;
    my ($name, $message) = @_;

    $self->{errors} ||= {};

    $self->{errors}->{$name} = $message;

    return $self;
}

sub errors {
    my $self = shift;

    return $self->{errors};
}

sub clear_errors {
    my $self = shift;

    # Clear field errors
    foreach my $field (CORE::values %{$self->{fields}}) {
        $field->error('');
    }

    # Clear group errors
    foreach my $group (@{$self->{groups}}) {
        $group->error('');
    }

    $self->{errors} = {};
}

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

    while (1) {
        $self->clear_errors;

        $self->_flag_unknown($params);

        $self->_populate_fields($params);

        $self->_validate_fields;
        $self->_validate_groups;

        my @conditions =
          grep { !$_->is_matched && $_->match($self->{fields}) }
          @{$self->{conditions}};
        last unless @conditions;

        foreach my $cond (@conditions) {
            $cond->then->($self);
        }
    }

    return $self->has_errors ? 0 : 1;
}

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

    foreach my $param (keys %$params) {
        if (!defined $self->{fields}->{$param}) {
            $self->{has_unknown_params} = 1;

            if ($self->{explicit}) {
                $self->error($param => $self->{messages}->{'NOT_SPECIFIED'}
                      || 'NOT_SPECIFIED');
            }
        }
    }
}

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

    foreach my $field (CORE::values %{$self->{fields}}) {
        $field->clear_value;

        $field->value($params->{$field->name});
    }
}

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

    foreach my $field (CORE::values %{$self->{fields}}) {
        next if $field->is_valid;

        $self->error($field->name => $field->error) if $field->error;
    }
}

sub _validate_groups {
    my $self = shift;

    foreach my $group (@{$self->{groups}}) {
        next if $group->is_valid;

        $self->error($group->name => $group->error) if $group->error;
    }
}

sub values {
    my $self = shift;

    my $values = {};

    foreach my $field (CORE::values %{$self->{fields}}) {
        $values->{$field->name} = $field->value
          if defined $field->value && !$field->error;
    }

    return $values;
}

sub all_values {
    my $self = shift;

    my $values = {};

    foreach my $field (CORE::values %{$self->{fields}}) {
        $values->{$field->name} = $field->value
          if defined $field->value;
    }

    return $values;
}

1;
__END__