root/lang/perl/Sledge-Plugin-FormValidator-Lazy/trunk/lib/Sledge/Plugin/FormValidator/Lazy.pm @ 5173

package Sledge::Plugin::FormValidator::Lazy;

use strict;
use warnings;

use vars qw/$CONSTRAINTS/ ;

use Data::FormValidator;
use UNIVERSAL::require;

our $VERSION = '0.01_01';

sub import {
    my $pkg     = caller(0);

    no strict 'refs'; ## no critic
        *{"$pkg\::create_validator"} = sub {
            my $self = shift;
            $self->{dfv_stash} = {};
            my $config = $self->create_config->form_validator_lazy;
            my $method_pkg = $config->{method_pkg}; 
            $method_pkg->require or die $@;
            $CONSTRAINTS->{_strict}
            = _make_constraints( $method_pkg , $config->{strict} , 'strict' );

            $CONSTRAINTS->{_loose}
            = _make_constraints( $method_pkg , $config->{loose} , 'loose' );

            $CONSTRAINTS->{_regexp}
            = _make_constraint_regexp_map( $method_pkg , $config->{regexp_map} );
        };

    *{"$pkg\::has_dfv_error"}       = \&has_dfv_error;
    *{"$pkg\::dfv_push_invalid"}    = \&dfv_push_invalid;
    *{"$pkg\::form"}            = \&form;
    *{"$pkg\::dfv_stash"}            = \&dfv_stash;


}

sub dfv_stash : lvalue {
    my $self = shift;
    $self->{dfv_stash} ||= {};
    $self->{dfv_stash};
}

#{{{ has_dfv_error
sub has_dfv_error {
    my $self = shift;

    if ( $self->form->has_invalid or $self->form->has_missing or exists $self->dfv_stash->{custom_invalid} ) {
        return 1;
    }
    else {
        return 0;
    }
}
#}}}
#{{{ dfv_push_invalid
sub dfv_push_invalid {
    my $self    = shift;
    my $key     = shift;
    $self->dfv_stash->{custom_invalid}{ $key } = 1;

}
#}}}

sub form {
    my $self    = shift;
    my $profile = shift;

    # FIXME use better implement of singleton if you can.
    unless ( defined $CONSTRAINTS ) {
        $self->create_validator();
    }

    if ( $profile ) {
        my $conf = $CONSTRAINTS ;
        my $custom_parameters = undef;

        if ( !$profile->{constraints} ) {
            my %constraints = %{ $CONSTRAINTS->{_strict} };
            $profile->{constraints} = \%constraints;

            if ( $profile->{constraints_loose} ) {
                for my $key ( @{ $profile->{constraints_loose} } ) {
                    $profile->{constraints}{ $key } = $CONSTRAINTS->{_loose}{ $key };
                }
                delete $profile->{constraints_loose};
            }

        }
        if( !$profile->{constraint_regexp_map} ) {
            $profile->{constraint_regexp_map} = $CONSTRAINTS->{_regexp} ;
        }

        if( $profile->{custom_parameters} ) {
            $custom_parameters = $profile->{custom_parameters} ;
            delete $profile->{custom_parameters} ;
        }


        $self->{form} =
          Data::FormValidator->check( $custom_parameters || $self->r , $profile );
        $self->dfv_stash->{valid} = $self->{form}{valid} ;
        $self->dfv_stash->{v} = $self->dfv_stash->{valid};
        for my $key ( $self->{form}->invalid  ) {
            $self->dfv_stash->{invalid}{ $key } = 1;
        }

        for my $key ( $self->{form}->missing  ) {
            $self->dfv_stash->{missing}{ $key } = 1;
        }
    }
    
    return $self->{form};


}
#{{{ _make_constraint_regexp_map
sub _make_constraint_regexp_map {
    my $pkg  = shift;
    my $data = shift;
    my $constraints = {};
    foreach my $key ( keys %{ $data } ) {
             my $value = $data->{ $key } ;
             if( ref $value eq 'ARRAY' ) {
                my $method = $value->[0]; 
                my @args = @{ $value };
                shift @args;
                my $sub =  $pkg . '::' . 'static' .  '_' .  $method  ;
                $constraints->{ qr/$key/ } 
                    = sub { 
                        my $item = shift ; 
                        no strict;
                        my $result =  $sub->( $item  ,@args );
                        return $result;
                      }
                    ;
             }
             else {
                $constraints->{ qr/$key/ } = qr/$value/;
             }
    }

    return $constraints;
}
#}}}


#{{{ _make_constraints
sub _make_constraints {
    my $pkg  = shift;
    my $data = shift;
    my $mode = shift;

    my $constraints = {};

    foreach my $key ( keys %{ $data } ) {
        my $value = $data->{ $key };

        if ( $value eq 'method' ) {
            local *glob =  $pkg . '::' . $mode .  '_' .  $key;
            $constraints->{ $key } = \&glob ;
        }
        elsif ( ref $value eq 'ARRAY' ) {
            my $method = $value->[0]; 
            my @args = @{ $value };
            shift @args;
            my $sub =  $pkg . '::' . 'static' .  '_' .  $method  ;
            $constraints->{ $key } 
                = sub { 
                    my $item = shift ; 
                    no strict;
                    my $result =  $sub->( $item  ,@args );
                    return $result;
                  }
                ;
        }
        else {
             $constraints->{ $key } = qr/$value/;
        }
    }
    return $constraints;
}
#}}}
1;

=head1 NAME

Sledge::Plugin::FormValidator::Lazy - use Data::FormValidator in lazy way

=head1 SYNOPSYS

 package Your::Pages;
 
 use Sledge::Plugin::FormValidator::Lazy;
 
 ;

conf.yaml
 
 form_validator_lazy :
    method_pkg : Your::Constraints
    strict :
        '_id$' : '^\d+'


 package Your::Pages::Root;

 sub dispatcher_index {
    my $self = shift;

    $self->form({
        requied => [qw/user_id member_id/],
        optional=> [qw/my_id/],
    });

    if( $self->has_dfv_error ) {
        $self->redirect('/error');
        return ;
    }

    my $v = $self->form->valid;

    my $user_id = $v->{user_id} ; 
 }

=head1 DESCRIPTION

This is still under develop, so be aware .

Implement Data::FormValidator in lazy way like L<Catalyst::Plugin::FormValidator::Lazy>

=head1 METHOD

=head2 import

=head2 has_dfv_error

=head2 form

=head2 dfv_push_invalid

=head2 dfv_stash

missing ,invalid , valid , custom_invalid 情報が格納されます。

=head1 SEE ALSO

L<Catalyst::Plugin::FormValidator::Lazy>

=head1 AUTHOR

Tomohiro Teranishi

=cut