root/lang/perl/FormValidator-LazyWay/branches/rebuild/lib/FormValidator/LazyWay.pm @ 13946

package FormValidator::LazyWay;

use Moose;
use FormValidator::LazyWay::Rule;
use FormValidator::LazyWay::Message;
use FormValidator::LazyWay::Utils;
use Carp;
use Data::Dumper;

has config  => ( is => 'ro', isa => 'HashRef' );
has rule    => ( is => 'ro', isa => 'FormValidator::LazyWay::Rule' );
has message => ( is => 'ro', isa => 'FormValidator::LazyWay::Message' );

sub BUILD {
    my $self = shift;
    croak 'you msue set config' unless $self->config;
    my $rule = FormValidator::LazyWay::Rule->new( config => $self->config );
    my $message = FormValidator::LazyWay::Message->new(
        config => $self->config,
        rule   => $rule
    );
    $self->{rule}    = $rule;
    $self->{message} = $message;
}

sub check {
    my $self    = shift;
    my $input   = shift;
    my %profile = %{ shift || {} };
    my $result  = {};
    my $storage = {
        valid   => FormValidator::LazyWay::Utils::get_input_as_hash($input),
        missing => [],
        unknown => [],
        invalid => {},
    };

    FormValidator::LazyWay::Utils::check_profile_syntax( \%profile );

    my @subs = (

        # profileを扱いやすい型にコンバート
        sub { $self->_conv_profile(@_) },

        # langをプロフィールにセット
        sub { $self->_set_lang(@_) },

        # デフォルトセット
        sub { $self->_set_default(@_) },

        # 空白のフィールドのキーを消去
        sub { $self->_remove_empty_fields(@_) },

        # 未定義のフィールドをセット、そしてvalidから消去
        sub { $self->_set_unknown(@_) },

        # missingのフィールドをセット、そしてvalidから消去
        sub { $self->_check_required_fields(@_) },

        # invalidチェックループ
        sub { $self->_validation_block(@_) },

        # エラーメッセージセット
        sub { $self->_set_error_message(@_) },
    );

    for my $sub (@subs) {
        $sub->( $storage, \%profile );
    }

    return FormValidator::LazyWay::Result->new($result);
}

sub _set_error_message {

}

sub _append_error_message {
    my $self          = shift;
    my $lang          = shift;
    my $level         = shift;
    my $field         = shift;
    my $storage       = shift;
    my $label         = shift;
    my $error_messages = shift;

    $storage->{invalid}{$field}{ $label } = 1;

    unless(  exists $error_messages->{$field} ) {
        $error_messages->{$field} = [];
    } 
    push @{ $error_messages->{$field} }, $self->message->get( { lang => $lang , field => $field, label => $label , level => $level } );

}

sub _validation_block {
    my $self           = shift;
    my $storage        = shift;
    my $profile        = shift;
    my $error_messages = {};

    my @fields = keys %{ $storage->{valid} };

    for my $field (@fields) {
        my $is_invalid = 0;
        my $level = $profile->{level}{$field} || 'strict';

        # missing , empty optional
        next unless exists $storage->{valid}{$field};

        # TODO : level
        my $validators = $self->_get_validator_methods( $field, $level );

        for my $validator ( @{$validators} ) {

            if ( ref $storage->{valid}{$field} eq 'ARRAY' ) {

            CHECK_ARRAYS:
                for my $v ( @{ $storage->{valid}{$field} } ) {
                    if ( $validators->{$field}{method}->( $storage->{valid}{$field} ) ) {
                        # OK
                        next CHECK_ARRAYS;
                    }
                    else {
                        $self->_append_error_message( $profile->{lang} , $level , $field , $storage , $validators->{$field}{label} , $error_messages);
                        $is_invalid++;
                        last CHECK_ARRAYS;
                    }
                }

                # 配列にする。
                # TODO : ループの中でやったほうがいいんじゃね？
                if ( none( @{ $profile->{want_array} } ) eq $field ) {
                    $storage->{valid}{$field} = $storage->{valid}{$field}[0];
                    last VALIDATE;
                }

            }
            else {
                if ( $validators->{$field}{method}->( $storage->{valid}{$field} ) ) {
                    # return alwasy array ref when want_array is seted.
                    if ( any( @{ $profile->{want_array} } ) eq $field ) {
                        my $value = $storage->{valid}{$field};
                        $storage->{valid}{$field} = [];
                        push @{ $storage->{valid}{$field} } , $value ;

                    }
                    else {
                        $self->_append_error_message( $profile->{lang} , $level , $field , $storage , $validators->{$field}{label} , $error_messages);
                        $is_invalid++;
                    }
                }
            }

        }
        delete $storage->{valid}{$field} if $is_invalid;
    }

}

sub _get_validator_methods {
    my $self  = shift;
    my $field = shift;
    my $level = shift;

    my $validators = $self->rule->constraints->{$level}{$field};

    if ( !defined $validators ) {

        # 正規表現にfieldがマッチしたら適応
        foreach my $regexp ( keys %{ $self->rule->constraints->{regex_map} } )
        {
            if ( $field =~ qr/$regexp/ ) {
                $validators = $self->rule->constraints->{regex_map}{$regexp};
                $level      = 'regex_map';
                last;
            }
        }

        # 検証モジュールがセットされてないよ。
        croak 'you should set ' . $level . ':' . $field . ' validate method'
            unless $validators;
    }

    return $validators;
}

sub _check_required_fields {
    my $self    = shift;
    my $storage = shift;
    my $profile = shift;

    for my $field ( keys %{ $profile->{required} } ) {
        push @{ $storage->{missing} }, $field
            unless exists $storage->{valid}{$field};
        delete $storage->{valid}{$field}
            unless exists $storage->{valid}{$field};
    }

    return 1;
}

sub _set_lang {
    my $self        = shift;
    my $storage     = shift;
    my $profile     = shift;

    $profile->{lang} = $profile->{lang} || $self->message->lang;
}

sub _conv_profile {
    my $self        = shift;
    my $storage     = shift;
    my $profile     = shift;
    my %new_profile = ();
    %{ $new_profile{required} } = map { $_ => 1 }
        FormValidator::LazyWay::Utils::arrayify( $profile->{required} );
    %{ $new_profile{optional} } = map { $_ => 1 }
        FormValidator::LazyWay::Utils::arrayify( $profile->{optional} );
    %{ $new_profile{want_array} } = map { $_ => 1 }
        FormValidator::LazyWay::Utils::arrayify( $profile->{want_array} );
    %{$profile} = ( %{$profile}, %new_profile );

    return 1;
}

sub _set_unknown {
    my $self    = shift;
    my $storage = shift;
    my $profile = shift;

    @{ $storage->{unknown} } = grep {
        not(   exists $profile->{optional}{$_}
            or exists $profile->{required}{$_} )
    } keys %{ $storage->{valid} };

    # and remove them from the list
    for my $field ( @{ $storage->{unknown} } ) {
        delete $storage->{valid}{$field};
    }

    return 1;
}

sub _set_default {
    my $self    = shift;
    my $storage = shift;

    if ( defined $self->rule->defaults ) {
        foreach my $field ( keys %{ $self->rule->defaults } ) {
            $storage->{valid}{$field} ||= $self->rule->defaults->{$field};
        }
    }

    return 1;
}

sub _remove_empty_fields {
    my $self    = shift;
    my $storage = shift;
    $storage->{valid} = FormValidator::LazyWay::Utils::remove_empty_fields(
        $storage->{valid} );

    return 1;
}

1;

=head1 NAME

FormValidator::LazyWay - Yet Another Form Validator 

=head1 SYNOPSYS

 my $fv = FormValidator::LazyWay->new( $config );

=head1 DESCRIPTION

=head1 AUTHOR

Tomohiro Teranishi <tomohiro.teranishi@gmail.com>

=cut