File Coverage

blib/lib/Input/Validator/Field.pm

Criterion	Covered	Total	%
statement	127	132	96.2
branch	67	76	88.1
condition	11	12	91.6
subroutine	24	24	100.0
pod	16	18	88.8
total	245	262	93.5

package Input::Validator::Field;

use strict;
use warnings;

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

use Input::Validator::Bulk;
use Input::Validator::ConstraintBuilder;

our $AUTOLOAD;

sub BUILD {
    my $self = shift;

    $self->{constraints} ||= [];
    $self->{messages}    ||= {};

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

    return $self;
}

sub name {
    my $self = shift;

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

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

    return $self;
}

sub required {
    my $self = shift;

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

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

    return $self;
}

sub inflate {
    my $self = shift;

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

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

    return $self;
}

sub deflate {
    my $self = shift;

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

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

    return $self;
}

sub trim {
    my $self = shift;

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

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

    return $self;
}

sub error {
    my $self = shift;

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

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

    return $self;
}

sub constraint {
    my $self = shift;

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

    push @{$self->{constraints}}, $constraint;

    return $self;
}

sub messages {
    my $self = shift;

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

    my @messages = @_ == 1 ? %{$_[0]} : @_;

    my %new_messages = @messages;

    foreach my $message (keys %new_messages) {
        $self->{messages}->{$message} = $new_messages{$message};
    }

    return $self;
}

sub error_to_message {
    my $self   = shift;
    my $error  = shift;
    my $params = shift || [];

    my $message = $self->{messages}->{$error};
    $message = $error unless defined $message;

    return sprintf($message, @$params);
}

sub multiple {
    my $self = shift;

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

    $self->{multiple} = [splice @_, 0, 2];

    return $self;
}

sub value {
    my $self = shift;

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

    my $value = shift;

    return unless defined $value;

    if ($self->multiple) {
        $self->{value} = ref($value) eq 'ARRAY' ? $value : [$value];
    }
    else {
        $self->{value} = ref($value) eq 'ARRAY' ? $value->[0] : $value;
    }

    return $self unless $self->trim;

    foreach ($self->multiple ? @{$self->{value}} : $self->{value}) {
        s/^\s+//;
        s/\s+$//;
    }

    return $self;
}

sub is_valid {
    my ($self) = @_;

    $self->error('');

    $self->error($self->error_to_message('REQUIRED')), return 0
      if $self->required && $self->is_empty;

    return 1 if $self->is_empty;

    my @values = $self->multiple ? @{$self->value} : $self->value;

    @values = map { &{$self->inflate} } @values if $self->inflate;

    if (my $multiple = $self->multiple) {
        my ($min, $max) = @$multiple;

        $self->error($self->error_to_message('NOT_ENOUGH')), return 0
          if @values < $min;
        $self->error($self->error_to_message('TOO_MUCH')), return 0
          if defined $max ? @values > $max : $min != 1 && @values != $min;
    }

    foreach my $c (@{$self->{constraints}}) {
        if ($c->is_multiple) {
            my ($ok, $error) = $c->is_valid([@values]);

            unless ($ok) {
                $self->error($self->error_to_message($c->error, $error));
                return 0;
            }
        }
        else {
            foreach my $value (@values) {
                my ($ok, $error) = $c->is_valid($value);

                unless ($ok) {
                    $self->error($self->error_to_message($c->error, $error));
                    return 0;
                }
            }
        }
    }

    @values = map { &{$self->deflate} } @values if $self->deflate;

    $self->value($self->multiple ? \@values : $values[0]);

    return 1;
}

sub clear_error {
    my $self = shift;

    delete $self->{error};
}

sub clear_value {
    my $self = shift;

    delete $self->{value};
}

sub each {
    my $self = shift;

    my $bulk = Input::Validator::Bulk->new(fields => [$self]);
    return $bulk->each(@_);
}

sub is_defined {
    my ($self) = @_;

    return defined $self->value ? 1 : 0;
}

sub is_empty {
    my ($self) = @_;

    return 1 unless $self->is_defined;

    if (ref $self->value eq 'ARRAY') {
        return @{$self->value} == 0;
    }

    return $self->value eq '' ? 1 : 0;
}

sub AUTOLOAD {
    my $self = shift;

    my $method = $AUTOLOAD;

    return if $method =~ /^[A-Z]+?$/;
    return if $method =~ /^_/;
    return if $method =~ /(?:\:*?)DESTROY$/;

    $method = (split '::' => $method)[-1];

    return $self->constraint($method => @_);
}

1;
__END__