Changeset 10735

Timestamp:

04/29/08 17:50:13 (5 years ago)

Author:

vkgtaro

Message:

Result クラスから LazyWay? へメソッド移行してみた

Location:

lang/perl/FormValidator-LazyWay/trunk/lib/FormValidator

Files:

• LazyWay.pm (modified) (6 diffs)
• LazyWay/Results.pm (modified) (3 diffs)

lang/perl/FormValidator-LazyWay/trunk/lib/FormValidator/LazyWay.pm

@@ -6 +6 @@
 use UNIVERSAL::require;
 use base qw/Class::Accessor::Fast/;
-use Perl6::Junction 'any';
+use Perl6::Junction qw/any none/;
+use FormValidator::LazyWay::Rules;
 use FormValidator::LazyWay::Results;
 
@@ -59 +60 @@
     $self->_check_profile_syntax($profile);
 
+    my $results = FormValidator::LazyWay::Results->new();
+
     my $static = {
         constraints => $self->{constraints},
@@ -65 +68 @@
         config      => $self->config,
     };
-
-    return FormValidator::LazyWay::Results->new( $input , $profile, $static ) ;
+    $results = $self->_process( $input, $profile, $static, $results );
+
+    return $results;
 }
 
@@ -200 +204 @@
 }
 
+sub _conv_message {
+    my $self     = shift;
+    my $config   = shift;
+    my $arg      = shift;
+    my $messages = shift;
+    my $field    = shift;
+    my $label    = shift;
+    my $type     = shift;
+    my $lang     = shift;
+    my $message  = $config->{messages}{$lang}{invalid}{$label} ||  $messages->{$label}{$lang};
+    my $args     = $arg->{$type}{$field}{$label} || {};
+
+    foreach my $key ( keys %{$args} ) {
+        my $regexp = '\$_\[' . $key . '\]';
+        my $value  = $args->{$key};
+        $message =~ s/$regexp/$value/g;
+    }
+
+    return $message;
+}
+
+sub _process {
+    my $self        = shift;
+
+    my $input       = shift;                        # 入力値
+    my $profile     = shift;                        # プロファイル
+    my $static      = shift;                        # スタティックデータ
+    my $results     = shift;                        # Results object
+
+    my $constraints = $static->{constraints};
+    my $messages    = $static->{messages};
+    my $config      = $static->{config};
+    my $args        = $static->{args};
+
+    my %data           = $self->_get_input_as_hash($input);
+    my %valid          = %data;
+    my $lang           = $profile->{lang} || $config->{lang} || 'en';
+    my $error_messages = {};
+    my @missings       = ();
+    my @unknown        = ();
+    my %invalid        = ();
+
+    if ( defined $profile->{defaults} ) {
+        foreach my $field ( keys %{ $profile->{defaults} } ) {
+            $valid{$field} ||= $profile->{defaults}{$field};
+        }
+    }
+
+    # Remove all empty fields
+    for my $field ( keys %valid ) {
+        if ( ref $valid{$field} ) {
+            next if ref $valid{$field} ne 'ARRAY';
+            for ( my $i = 0; $i < scalar @{ $valid{$field} }; $i++ ) {
+                $valid{$field}->[$i] = undef
+                    unless ( defined $valid{$field}->[$i]
+                            and length $valid{$field}->[$i]
+                            and $valid{$field}->[$i] !~ /^\x00$/ );
+            }
+
+            # If all fields are empty, we delete it.
+            delete $valid{$field}
+                unless grep { defined $_ } @{ $valid{$field} };
+        }
+        else {
+            delete $valid{$field}
+                unless ( defined $valid{$field}
+                        and length $valid{$field}
+                        and $valid{$field} !~ /^\x00$/ );
+        }
+    }
+
+    my %required = map { $_ => 1 } _arrayify( $profile->{required} );
+    my %optional = map { $_ => 1 } _arrayify( $profile->{optional} );
+
+    my %required_one_or_more
+        = map { $_ => 1 } _arrayify( $profile->{required_one_or_more} );
+    my %optional_one_or_more
+        = map { $_ => 1 } _arrayify( $profile->{optional_one_or_more} );
+
+    # Find unknown
+    @unknown = grep { not( exists $optional{$_} or exists $required{$_} ) }
+        keys %valid;
+
+    # and remove them from the list
+    for my $field (@unknown) {
+        delete $valid{$field};
+    }
+
+    # Check for required fields
+    for my $field ( keys %required ) {
+        push @missings, $field unless exists $valid{$field};
+        delete $valid{$field}  unless exists $valid{$field};
+    }
+
+# Check must_be_plural
+# TODO : even user set too much prameters which generate missing error which look strange....
+    foreach my $field ( keys %{ $profile->{must_be_plural} } ) {
+        if ( ref $valid{$field} eq 'ARRAY' ) {
+            unless (
+                scalar @{ $valid{$field} }
+                == $profile->{must_be_plural}{$field} )
+            {
+                push @missings, $field;
+                delete $valid{$field};
+            }
+        }
+        else {
+            push @missings, $field;
+            delete $valid{$field};
+
+        }
+    }
+
+    for my $field ( keys %required ) {
+        my $is_invalid = 0;
+        # if no valud do not need to check it
+        next if any(@missings) eq $field;
+
+        my $validators
+            = any( @{ $profile->{use_loose} } ) eq $field
+            ? $constraints->{loose}{$field}
+            : $constraints->{strict}{$field};
+
+        my $type = {};
+        if ( any( @{ $profile->{use_loose} } ) eq $field ) {
+            $validators = $constraints->{loose}{$field};
+            $type->{$field} = 'loose';
+        }
+        else {
+            $validators = $constraints->{strict}{$field};
+            $type->{$field} = 'strict';
+        }
+
+        # regexp_map try~
+        if ( !defined $validators ) {
+            foreach my $regexp ( keys %{ $constraints->{regex_map} } ) {
+                if ( $field =~ qr/$regexp/ ) {
+                    $validators = $constraints->{regex_map}{$regexp};
+                    $type->{$field} = 'regex_map';
+                }
+            }
+        }
+
+        if ( ! defined $validators ) {
+            warn 'you should set ' . $field . ' validate method';
+        }
+        else {
+
+            foreach my $name ( keys %{$validators} ) {
+                if ( ref $valid{$field} eq 'ARRAY' ) {
+                    for my $v ( @{ $valid{$field} } ) {
+                        if ($validators->{$name}{method}->( $valid{$field} ) )
+                        {
+
+                            # ok!
+                        }
+                        else {
+                            $invalid{$field}{ $validators->{$name}{label} }
+                                = 1;
+                            $error_messages->{$field} = []
+                                unless exists $error_messages->{$field};
+                            push @{ $error_messages->{$field} },
+                                $self->_conv_message( $config ,$args,  $messages, $field, $validators->{$name}{label}, $type->{$field} , $lang  );
+                                $is_invalid++;
+                            last;
+                        }
+                    }
+
+                    if ( !defined $profile->{must_be_plural}{$field}
+                        && none( @{ $profile->{may_be_plural} } ) eq $field )
+                    {
+                        $valid{$field} = $valid{$field}[0];
+                        last;
+                    }
+
+                }
+                else {
+                    if ( $validators->{$name}{method}->( $valid{$field} ) ) {
+
+                        # return alwasy array ref when may_be_plural is seted.
+                        if ( any( @{ $profile->{may_be_plural} } ) eq $field )
+                        {
+                            my $value = $valid{$field};
+                            $valid{$field} = [];
+                            push @{ $valid{$field} }, $value;
+                        }
+
+                    }
+                    else {
+                        $invalid{$field}{ $validators->{$name}{label} } = 1;
+                        $error_messages->{$field} = []
+                            unless exists $error_messages->{$field};
+                        push @{ $error_messages->{$field} },
+                            $self->_conv_message( $config , $args, $messages, $field, $validators->{$name}{label}, $type->{$field} , $lang );
+                            $is_invalid++;
+                    }
+                }
+            }
+        }
+
+        delete $valid{$field} if $is_invalid;
+    }
+
+    foreach my $field ( keys %{ $error_messages} ) {
+        local $" = ',';
+        my $tmp =  "@{$error_messages->{$field}}" ;
+        my $mes = $config->{messages}{ $lang }{ invalid_message } || FormValidator::LazyWay::Rules->mes_invalid->{ $lang };
+        $mes =~ s/__rule__/$tmp/g;
+        my $label = $config->{labels}{ $lang }{$field} || $field;
+        $mes =~ s/__field__/$label/g;
+        $error_messages->{$field} = $mes;
+    }
+
+# FIXME : Just for now.
+# invalid , missing もそうだけど、 __field__ とかの置き換えするとかで、フィールド名も表示できたほがいいよな。
+    if ( scalar @missings ) {
+        for my $missing (@missings) {
+            $error_messages->{$missing}  =  'missing.';
+        }
+    }
+
+
+    $results->{valid}          = \%valid;
+    $results->{invalid}        = \%invalid;
+    $results->{missing}        = \@missings;
+    $results->{unknown}        = \@unknown;
+    $results->{error_messages} = $error_messages;
+
+    $results->{has_missing} = scalar @missings ? 1 : 0;
+    $results->{has_invalid} = keys %invalid    ? 1 : 0;
+    $results->{has_error} = $results->{has_missing} || $results->{has_invalid} ? 1 : 0;
+
+    #inverted truth-value.
+    $results->{success} = $results->{has_error} ? 0 : 1;
+
+    $results;
+}
+
+# takes string or array ref as input
+# returns array
+sub _arrayify {
+
+    # if the input is undefined, return an empty list
+    my $val = shift;
+    defined $val or return ();
+
+# if it's a reference, return an array unless it points to an empty array. -mls
+    if ( ref $val eq 'ARRAY' ) {
+        $^W = 0;    # turn off warnings about undef
+        return ( any(@$val) ne undef ) ? @$val : ();
+    }
+
+# if it's a string, return an array unless the string is missing or empty. -mls
+    else {
+        return ( length $val ) ? ($val) : ();
+    }
+}
+
+# Figure out whether the data is a hash reference of a param-capable object and return it has a hash
+sub _get_input_as_hash {
+    my ( $self, $data ) = @_;
+    require Scalar::Util;
+
+    # This checks whether we have an object that supports param
+    if ( Scalar::Util::blessed($data) && $data->can('param') ) {
+        my %return;
+        for my $k ( $data->param() ) {
+
+            # we expect param to return an array if there are multiple values
+            my @v;
+
+          # CGI::Simple requires us to call 'upload()' to get upload data,
+          # while CGI/Apache::Request return it on calling 'param()'.
+          #
+          # This seems quirky, but there isn't a way for us to easily check if
+          # "this field contains a file upload" or not.
+            if ( $data->isa('CGI::Simple') ) {
+                @v = $data->upload($k) || $data->param($k);
+            }
+            else {
+                @v = $data->param($k);
+            }
+
+            # we expect param to return an array if there are multiple values
+            $return{$k} = scalar(@v) > 1 ? \@v : $v[0];
+        }
+        return %return;
+    }
+
+    # otherwise, it's already a hash reference
+    elsif ( ref $data eq 'HASH' ) {
+
+        # be careful to actually copy array references
+        my %copy = %$data;
+        for ( grep { ref $data->{$_} eq 'ARRAY' } keys %$data ) {
+            my @array_copy = @{ $data->{$_} };
+            $copy{$_} = \@array_copy;
+        }
+
+        return %copy;
+    }
+    else {
+        die
+            "FormValidator::LazyWay->validate() or check() called with invalid input data structure.";
+    }
+}
+
 1;
 
@@ -212 +523 @@
 This is yet another form validator!
 
-Most of validator is made for a form but not forms on a site. That is why I made this. This module let you allow to set validation for globally.
+Most of validator is made for a form but not forms on a site.
+That is why I made this. This module let you allow to set validation for globally.
 
 =head1 METHOD
@@ -225 +537 @@
 
 =head2 constraints
+
+=head2 _conv_message
+
+=head2 _process
+
+=head2 _arrayify
+
+=head2 _get_input_as_hash
 
 =head1 INTERNALS

lang/perl/FormValidator-LazyWay/trunk/lib/FormValidator/LazyWay/Results.pm

@@ -4 +4 @@
 use warnings;
 use base qw/Class::Accessor::Complex/;
-use Perl6::Junction qw/any none/;
 use Carp;
 use Data::Dumper;
-use FormValidator::LazyWay::Rules;
 
 __PACKAGE__->mk_accessors(
@@ -32 +30 @@
 sub new {
     my $class   = shift;
-    my $input   = shift;
-    my $profile = shift;
-    my $static  = shift;
 
     my $self = bless {}, $class;
     $self->{custom_invalid} = [];
-    $self->_process( $input, $profile , $static );
     return $self;
 }
 
-sub _conv_message {
-    my $self     = shift;
-    my $config   = shift;
-    my $arg      = shift;
-    my $messages = shift;
-    my $field    = shift;
-    my $label    = shift;
-    my $type     = shift;
-    my $lang     = shift;
-    my $message  = $config->{messages}{$lang}{invalid}{$label} ||  $messages->{$label}{$lang};
-    my $args     = $arg->{$type}{$field}{$label} || {};
-
-    foreach my $key ( keys %{$args} ) {
-        my $regexp = '\$_\[' . $key . '\]';
-        my $value  = $args->{$key};
-        $message =~ s/$regexp/$value/g;
-    }
-
-    return $message;
-}
-
-sub _process {
-    my $self        = shift;
-
-    my $input       = shift;                        # 入力値
-    my $profile     = shift;                        # プロファイル
-    my $static      = shift;                        # スタティックデータ
-    my $constraints = $static->{constraints};
-    my $messages    = $static->{messages};
-    my $config      = $static->{config};
-    my $args        = $static->{args};
-
-    my %data           = $self->_get_input_as_hash($input);
-    my %valid          = %data;
-    my $lang           = $profile->{lang} || $config->{lang} || 'en';
-    my $error_messages = {};
-    my @missings       = ();
-    my @unknown        = ();
-    my %invalid        = ();
-
-    if ( defined $profile->{defaults} ) {
-        foreach my $field ( keys %{ $profile->{defaults} } ) {
-            $valid{$field} ||= $profile->{defaults}{$field};
-        }
-    }
-
-    # Remove all empty fields
-    for my $field ( keys %valid ) {
-        if ( ref $valid{$field} ) {
-            next if ref $valid{$field} ne 'ARRAY';
-            for ( my $i = 0; $i < scalar @{ $valid{$field} }; $i++ ) {
-                $valid{$field}->[$i] = undef
-                    unless ( defined $valid{$field}->[$i]
-                            and length $valid{$field}->[$i]
-                            and $valid{$field}->[$i] !~ /^\x00$/ );
-            }
-
-            # If all fields are empty, we delete it.
-            delete $valid{$field}
-                unless grep { defined $_ } @{ $valid{$field} };
-        }
-        else {
-            delete $valid{$field}
-                unless ( defined $valid{$field}
-                        and length $valid{$field}
-                        and $valid{$field} !~ /^\x00$/ );
-        }
-    }
-
-    my %required = map { $_ => 1 } _arrayify( $profile->{required} );
-    my %optional = map { $_ => 1 } _arrayify( $profile->{optional} );
-
-    my %required_one_or_more
-        = map { $_ => 1 } _arrayify( $profile->{required_one_or_more} );
-    my %optional_one_or_more
-        = map { $_ => 1 } _arrayify( $profile->{optional_one_or_more} );
-
-    # Find unknown
-    @unknown = grep { not( exists $optional{$_} or exists $required{$_} ) }
-        keys %valid;
-
-    # and remove them from the list
-    for my $field (@unknown) {
-        delete $valid{$field};
-    }
-
-    # Check for required fields
-    for my $field ( keys %required ) {
-        push @missings, $field unless exists $valid{$field};
-        delete $valid{$field}  unless exists $valid{$field};
-    }
-
-# Check must_be_plural
-# TODO : even user set too much prameters which generate missing error which look strange....
-    foreach my $field ( keys %{ $profile->{must_be_plural} } ) {
-        if ( ref $valid{$field} eq 'ARRAY' ) {
-            unless (
-                scalar @{ $valid{$field} }
-                == $profile->{must_be_plural}{$field} )
-            {
-                push @missings, $field;
-                delete $valid{$field};
-            }
-        }
-        else {
-            push @missings, $field;
-            delete $valid{$field};
-
-        }
-    }
-
-    for my $field ( keys %required ) {
-        my $is_invalid = 0;
-        # if no valud do not need to check it
-        next if any(@missings) eq $field;
-
-        my $validators
-            = any( @{ $profile->{use_loose} } ) eq $field
-            ? $constraints->{loose}{$field}
-            : $constraints->{strict}{$field};
-
-        my $type = {};
-        if ( any( @{ $profile->{use_loose} } ) eq $field ) {
-            $validators = $constraints->{loose}{$field};
-            $type->{$field} = 'loose';
-        }
-        else {
-            $validators = $constraints->{strict}{$field};
-            $type->{$field} = 'strict';
-        }
-
-        # regexp_map try~
-        if ( !defined $validators ) {
-            foreach my $regexp ( keys %{ $constraints->{regex_map} } ) {
-                if ( $field =~ qr/$regexp/ ) {
-                    $validators = $constraints->{regex_map}{$regexp};
-                    $type->{$field} = 'regex_map';
-                }
-            }
-        }
-
-        if ( ! defined $validators ) {
-            warn 'you should set ' . $field . ' validate method';
-        }
-        else {
-
-            foreach my $name ( keys %{$validators} ) {
-                if ( ref $valid{$field} eq 'ARRAY' ) {
-                    for my $v ( @{ $valid{$field} } ) {
-                        if ($validators->{$name}{method}->( $valid{$field} ) )
-                        {
-
-                            # ok!
-                        }
-                        else {
-                            $invalid{$field}{ $validators->{$name}{label} }
-                                = 1;
-                            $error_messages->{$field} = []
-                                unless exists $error_messages->{$field};
-                            push @{ $error_messages->{$field} },
-                                $self->_conv_message( $config ,$args,  $messages, $field, $validators->{$name}{label}, $type->{$field} , $lang  );
-                                $is_invalid++;
-                            last;
-                        }
-                    }
-
-                    if ( !defined $profile->{must_be_plural}{$field}
-                        && none( @{ $profile->{may_be_plural} } ) eq $field )
-                    {
-                        $valid{$field} = $valid{$field}[0];
-                        last;
-                    }
-
-                }
-                else {
-                    if ( $validators->{$name}{method}->( $valid{$field} ) ) {
-
-                        # return alwasy array ref when may_be_plural is seted.
-                        if ( any( @{ $profile->{may_be_plural} } ) eq $field )
-                        {
-                            my $value = $valid{$field};
-                            $valid{$field} = [];
-                            push @{ $valid{$field} }, $value;
-                        }
-
-                    }
-                    else {
-                        $invalid{$field}{ $validators->{$name}{label} } = 1;
-                        $error_messages->{$field} = []
-                            unless exists $error_messages->{$field};
-                        push @{ $error_messages->{$field} },
-                            $self->_conv_message( $config , $args, $messages, $field, $validators->{$name}{label}, $type->{$field} , $lang );
-                            $is_invalid++;
-                    }
-                }
-            }
-        }
-
-        delete $valid{$field} if $is_invalid;
-    }
-
-    foreach my $field ( keys %{ $error_messages} ) {
-        local $" = ',';
-        my $tmp =  "@{$error_messages->{$field}}" ;
-        my $mes = $config->{messages}{ $lang }{ invalid_message } || FormValidator::LazyWay::Rules->mes_invalid->{ $lang };
-        $mes =~ s/__rule__/$tmp/g;
-        my $label = $config->{labels}{ $lang }{$field} || $field;
-        $mes =~ s/__field__/$label/g;
-        $error_messages->{$field} = $mes;
-    }
-
-# FIXME : Just for now.
-# invalid , missing もそうだけど、 __field__ とかの置き換えするとかで、フィールド名も表示できたほがいいよな。
-    if ( scalar @missings ) {
-        for my $missing (@missings) {
-            $error_messages->{$missing}  =  'missing.';
-        }
-    }
-
-
-    $self->{valid}          = \%valid;
-    $self->{invalid}        = \%invalid;
-    $self->{missing}        = \@missings;
-    $self->{unknown}        = \@unknown;
-    $self->{error_messages} = $error_messages;
-
-    $self->{has_missing} = scalar @missings ? 1 : 0;
-    $self->{has_invalid} = keys %invalid    ? 1 : 0;
-    $self->{has_error} = $self->{has_missing} || $self->{has_invalid} ? 1 : 0;
-
-    #inverted truth-value.
-    $self->{success} = $self->{has_error} ? 0 : 1;
-
-}
-
-# takes string or array ref as input
-# returns array
-sub _arrayify {
-
-    # if the input is undefined, return an empty list
-    my $val = shift;
-    defined $val or return ();
-
-# if it's a reference, return an array unless it points to an empty array. -mls
-    if ( ref $val eq 'ARRAY' ) {
-        $^W = 0;    # turn off warnings about undef
-        return ( any(@$val) ne undef ) ? @$val : ();
-    }
-
-# if it's a string, return an array unless the string is missing or empty. -mls
-    else {
-        return ( length $val ) ? ($val) : ();
-    }
-}
-
-# Figure out whether the data is a hash reference of a param-capable object and return it has a hash
-sub _get_input_as_hash {
-    my ( $self, $data ) = @_;
-    require Scalar::Util;
-
-    # This checks whether we have an object that supports param
-    if ( Scalar::Util::blessed($data) && $data->can('param') ) {
-        my %return;
-        for my $k ( $data->param() ) {
-
-            # we expect param to return an array if there are multiple values
-            my @v;
-
-          # CGI::Simple requires us to call 'upload()' to get upload data,
-          # while CGI/Apache::Request return it on calling 'param()'.
-          #
-          # This seems quirky, but there isn't a way for us to easily check if
-          # "this field contains a file upload" or not.
-            if ( $data->isa('CGI::Simple') ) {
-                @v = $data->upload($k) || $data->param($k);
-            }
-            else {
-                @v = $data->param($k);
-            }
-
-            # we expect param to return an array if there are multiple values
-            $return{$k} = scalar(@v) > 1 ? \@v : $v[0];
-        }
-        return %return;
-    }
-
-    # otherwise, it's already a hash reference
-    elsif ( ref $data eq 'HASH' ) {
-
-        # be careful to actually copy array references
-        my %copy = %$data;
-        for ( grep { ref $data->{$_} eq 'ARRAY' } keys %$data ) {
-            my @array_copy = @{ $data->{$_} };
-            $copy{$_} = \@array_copy;
-        }
-
-        return %copy;
-    }
-    else {
-        die
-            "FormValidator::LazyWay->validate() or check() called with invalid input data structure.";
-    }
-}
 1;
 
@@ -354 +45 @@
 
 =head2 new
+
+=head2 custom_invalid
 
 =head1 ACCESSORS