FormValidator::Simple::Results - results of validation

    my $results = FormValidator::Simple->check( $req => [
        name  => [qw/NOT_BLANK ASCII/, [qw/LENGTH 0 10/] ],
        email => [qw/NOT_BLANK EMAIL_LOOSE/, [qw/LENGTH 0 30/] ],
    ] );

    if ( $results->has_error ) {
        foreach my $key ( @{ $results->error() } ) {
            foreach my $type ( @{ $results->erorr($key) } ) {
                print "invalid: $key - $type \n";
            }
        }
    }

    my $error_keys = $results->error;

    my $failed_validation = $resuls->error('name');
    # this includes 'NOT_BLANK'

    if ( $results->error( name => 'NOT_BLANK' ) ) {
        print "name is missing! \n";
    }

    if ( $results->error( name => 'ASCII' ) ) {
        print "name should be ascii code! \n";
    }

package FormValidator::Simple::Results;
use strict;
use base qw/Class::Accessor::Fast/;
use FormValidator::Simple::Result;
use FormValidator::Simple::Exception;
use FormValidator::Simple::Constants;
use Tie::IxHash;
use List::MoreUtils;

__PACKAGE__->mk_accessors(qw/_records message/);

sub new {
    my $class = shift;
    my $self  = bless { }, $class;
    $self->_init(@_);
    return $self;
}

sub _init {
    my ($self, %args) = @_;
    my %hash = ();
    tie (%hash, 'Tie::IxHash');
    $self->_records(\%hash);

    my $messages = delete $args{messages};
    $self->message($messages);
}

sub messages {
    my ($self, $action) = @_;
    my @messages = ();
    my $keys = $self->error;
    foreach my $key ( @$keys ) {
        my $types = $self->error($key);
        foreach my $type ( @$types ) {
            push @messages,
                $self->message->get($action, $key, $type);
        }
    }
    @messages = List::MoreUtils::uniq(@messages);
    return \@messages;
}

sub field_messages {
    my ($self, $action) = @_;
    my $messages = {};
    my $keys = $self->error;
    foreach my $key ( @$keys ) {
        $messages->{$key} = [];
        my $types = $self->error($key);
        foreach my $type ( @$types ) {
            my $message = $self->message->get($action, $key, $type);
            unless ( List::MoreUtils::any { $_ eq $message } @{ $messages->{$key} } ) {
                push @{ $messages->{$key} }, $message;
            }
        }
    }
    return $messages;
}

sub register {
    my ($self, $name) = @_;
    $self->_records->{$name}
        ||= FormValidator::Simple::Result->new($name);
}

sub record {
    my ($self, $name) = @_;
    $self->register($name)
    unless exists $self->_records->{$name};
    return $self->_records->{$name};
}

sub set_result {
    my ($self, $name, $type, $result) = @_;
    $self->register($name);
    $self->record($name)->set($type, $result);
}

sub set_invalid {
    my ($self, $name, $type) = @_;
    unless ($name && $type) {
        FormValidator::Simple::Exception->throw(
            qq/set_invalid needs two arguments./
        );
    }
    $self->set_result($name, $type, FALSE);
}

sub success {
    my $self = shift;
    return ($self->has_missing or $self->has_invalid) ? FALSE : TRUE;
}

sub has_error {
    my $self = shift;
    return ($self->has_missing or $self->has_invalid) ? TRUE : FALSE;
}

sub has_blank {
    my $self = shift;
    foreach my $record ( values %{ $self->_records } ) {
        return TRUE if $record->is_blank;
    }
    return FALSE;
}

*has_missing = \&has_blank;

sub has_invalid {
    my $self = shift;
    foreach my $record ( values %{ $self->_records } ) {
        return TRUE if $record->is_invalid;
    }
    return FALSE;
}

sub valid {
    my ($self, $name) = @_;
    if ($name) {
        return unless exists $self->_records->{$name};
        return $self->record($name)->is_valid
             ? $self->record($name)->data : FALSE;
    }
    else {
        my %valids
            = map { ( $_->name, $_->data ) } grep { $_->is_valid } values %{ $self->_records };
        return \%valids;
    }
}

sub error {
    my ($self, $name, $constraint) = @_;
    if ($name) {
        if ($constraint) {
            if ($constraint eq 'NOT_BLANK') {
            return $self->record($name)->is_blank
                ? TRUE
                : FALSE
                ;
            }
            return $self->record($name)->is_invalid_for($constraint)
                ? TRUE
                : FALSE
                ;
        }
        else {
            if ($self->record($name)->is_blank) {
                return wantarray ? 'NOT_BLANK' : ['NOT_BLANK'];
            }
            elsif ($self->record($name)->is_invalid) {
                my $constraints = $self->record($name)->constraints;
                my @invalids = grep { !$constraints->{$_} } keys %$constraints;
                return wantarray ? @invalids : \@invalids;
            }
            else {
                return FALSE;
            }
        }
    }
    else {
        my @errors = 
        map { $_->name } grep { $_->is_blank or $_->is_invalid } values %{ $self->_records };
        return wantarray ? @errors : \@errors;
    }
}

sub blank {
    my ($self, $name) = @_;
    if ($name) {
        return $self->record($name)->is_blank ? TRUE : FALSE;
    }
    else {
        my @blanks
            = map { $_->name } grep { $_->is_blank } values %{ $self->_records };
        return wantarray ? @blanks : \@blanks;
    }
}

*missing = \␣

sub invalid {
    my ($self, $name, $constraint) = @_;
    if ($name) {
        if ($constraint) {
            $self->record($name)->is_invalid_for($constraint)
                ? TRUE : FALSE;
        }
        else {
            if ($self->record($name)->is_invalid) {
                my $constraints = $self->record($name)->constraints;
                my @invalids = grep { !$constraints->{$_} } keys %$constraints;
                return wantarray ? @invalids : \@invalids;
            }
            else {
                return FALSE;
            }
        }
    }
    else {
        my @invalids
            = map { $_->name } grep { $_->is_invalid } values %{ $self->_records };
        return wantarray ? @invalids : \@invalids;
    }
}

sub clear {
  %{shift->_records} = ();
}

1;
__END__