File Coverage

blib/lib/FormValidator/Lite.pm

Criterion	Covered	Total	%
statement	142	149	95.3
branch	48	64	75.0
condition	4	12	33.3
subroutine	28	29	96.5
pod	16	16	100.0
total	238	270	88.1

package FormValidator::Lite;
use strict;
use warnings;
use 5.008_001;
use Carp ();
use Scalar::Util qw/blessed/;
use FormValidator::Lite::Constraint::Default;
use FormValidator::Lite::Upload;
use Class::Accessor::Lite 0.05 (
    rw => [qw/query/]
);
use Class::Load ();
use FormValidator::Lite::Hash;

our $VERSION = '0.38';

our $Rules;
our $FileRules;

sub import {
    my ($class, @constraints) = @_;
    $class->load_constraints(@constraints);
}

sub new {
    my ($class, $q) = @_;
    Carp::croak("Usage: ${class}->new(\$q)") unless $q;

    if (ref $q eq 'HASH') {
        $q = FormValidator::Lite::Hash->new($q);
    } elsif (UNIVERSAL::isa($q, 'Hash::MultiValue')) {
        $q = FormValidator::Lite::Hash->new($q->flatten);
    }
    bless { query => $q, _error => {} }, $class;
}

sub check {
    my ($self, @rule_ary) = @_;
    Carp::croak("this is an instance method") unless ref $self;

    while (my ($rule_key, $rules) = splice(@rule_ary, 0, 2)) {
        my ($key, @values) = $self->_extract_values($rule_key);
        for my $value (@values) {
            local $_ = $value;
            for my $rule (@$rules) {
                my $rule_name = ref($rule) ? $rule->[0]                          : $rule;
                my $args      = ref($rule) ? [ @$rule[ 1 .. scalar(@$rule)-1 ] ] : +[];

                if ($FileRules->{$rule_name}) {
                    $_ = FormValidator::Lite::Upload->new($self->{query}, $key);
                }
                my $is_ok = do {
                    if ((not (defined $_ && length $_)) && $rule_name !~ /^(NOT_NULL|NOT_BLANK|REQUIRED)$/) {
                        1;
                    } else {
                        if (my $file_rule = $FileRules->{$rule_name}) {
                            $file_rule->(@$args) ? 1 : 0;
                        } else {
                            my $code = $Rules->{$rule_name} or Carp::croak("unknown rule $rule_name");
                            $code->(@$args) ? 1 : 0;
                        }
                    }
                };
                if ($is_ok==0) {
                    $self->set_error($key => $rule_name);
                }
            }
        }
    }

    return $self;
}

sub _extract_values {
    my ($self, $key) = @_;

    local $CGI::LIST_CONTEXT_WARN = 0;
    my $q = $self->{query};
    my @values;
    if (ref $key) {
        $key = [%$key];
        @values = [ map { $q->param($_) } @{ $key->[1] } ];
        $key = $key->[0];
    } else {
        @values = defined $q->param($key) ? $q->param($key) : undef;
    }
    return ($key, @values);
}

sub is_error {
    my ($self, $key) = @_;
    $self->{_error}->{$key} ? 1 : 0;
}

sub is_valid {
    my $self = shift;
    !$self->has_error ? 1 : 0;
}

sub has_error {
    my ($self, ) = @_;
    %{ $self->{_error} } ? 1 : 0;
}

sub set_error {
    my ($self, $param, $rule_name) = @_;
    $self->{_error}->{$param}->{$rule_name}++;
    push @{$self->{_error_ary}}, [$param, $rule_name];
}

sub errors {
    my ($self) = @_;
    $self->{_error};
}

sub load_constraints {
    my $class = shift;
    for (@_) {
        my $constraint = $_;
        $constraint = ($constraint =~ s/^\+//) ? $constraint : "FormValidator::Lite::Constraint::${constraint}";
        Class::Load::load_class($constraint);
    }
}

sub load_function_message {
    my ($self, $lang) = @_;
    my $pkg = "FormValidator::Lite::Messages::$lang";
    Class::Load::load_class($pkg);

    no strict 'refs';
    $self->{_msg}->{function} = ${"${pkg}::MESSAGES"};
}

sub set_param_message {
    my ($self, %args) = @_;
    $self->{_msg}->{param} = \%args;
}

sub set_message_data {
    my ($self, $msg) = @_;
    for my $key (qw/param function/) {
        Carp::croak("missing key $key") unless $msg->{$key};
    }
    $self->{_msg} = $msg;
}

sub set_message {
    my ($self, @args) = @_;
    my %msg = ref $args[0] ? %{$args[0]} : @args;
    $self->{_msg}->{message} = +{
        %{ $self->{_msg}->{message} || +{} },
        %msg
    };
}

sub get_error_messages {
    my $self = shift;
    Carp::croak("No messages loaded yet") unless $self->{_msg};

    my %dup_check;
    my @messages;
    for my $err (@{$self->{_error_ary}}) {
        my $param = $err->[0];
        my $func  = $err->[1];

        next if exists $dup_check{"$param.$func"};
        push @messages, $self->get_error_message( $param, $func );
        $dup_check{"$param.$func"}++;
    }

    return wantarray ? @messages : \@messages;
}

# $validator->get_error_message('email', 'NOT_NULL');
sub get_error_message {
    my ($self, $param, $function) = @_;
    $function = lc($function);

    my $msg = $self->{_msg};
    Carp::croak("please load message file first") unless $msg;

    my $err_message  = $msg->{message}->{"${param}.${function}"};
    my $err_param    = $msg->{param}->{$param};
    my $err_function = $msg->{function}->{$function};

    if ($err_message) {
        return $self->build_message($err_message, $err_param);
    } elsif ($err_function && $err_param) {
        return $self->build_message($err_function, $err_param);
    } else {
        Carp::carp  "${param}.${function} is not defined in message file.";
        if ($msg->{default_tmpl}) {
            return $self->build_message($err_function || $msg->{default_tmpl}, $err_function || $param);
        } else {
            return '';
        }
    }
}

sub build_message {
    my ($self, $tmpl, @args) = @_;
    local $_ = $tmpl;
    s!\[_(\d+)\]!$args[$1-1]!ge;
    $_;
}

sub get_error_messages_from_param {
    my ($self, $target_param) = @_;

    my %dup_check;
    my @messages;
    for my $err (@{$self->{_error_ary}}) {
        my $param = $err->[0];
        my $func  = $err->[1];

        next if $target_param ne $param;
        next if exists $dup_check{"$param.$func"};
        push @messages, $self->get_error_message( $param, $func );
        $dup_check{"$param.$func"}++;
    }

    return wantarray ? @messages : \@messages;
}

1;

__END__