File Coverage

blib/lib/WWW/FieldValidator.pm

Criterion	Covered	Total	%
statement	48	65	73.8
branch	10	20	50.0
condition	4	13	30.7
subroutine	12	15	80.0
pod	3	3	100.0
total	77	116	66.3

package WWW::FieldValidator;
$WWW::FieldValidator::VERSION = '1.23';
use 5.014;
use strict;
use warnings;

# The following constants represent the validator types that can be used to
# validate the specified user input.
use constant WELL_FORMED_EMAIL => 1;
use constant MIN_STR_LENGTH    => 2;
use constant MAX_STR_LENGTH    => 5;
use constant REGEX_MATCH       => 3;
use constant USER_DEFINED_SUB  => 4;

# Create a new Validator object.
sub new {
    my $class  = shift;

    # The type of validation the instance will use
    my $validatorType = shift;

    # The error feedback to return if the test data does not pass validation
    my $feedback = shift;

    my $self = {};

    bless($self, $class);

    $self->{feedback}      = $feedback;
    $self->{validatorType} = $validatorType;

    if ($validatorType == MIN_STR_LENGTH) {

        # Set min length to 1 by default
        my $minLength      = shift || 1;
        $self->{minLength} = $minLength;

    }
    elsif ($validatorType == REGEX_MATCH) {

        my $regex      = shift;
        $self->{regex} = $regex;

    }
    elsif ($validatorType == USER_DEFINED_SUB) {

        my $subRef    = shift;
        $self->{usub} = $subRef;

    }
    elsif ($validatorType == MAX_STR_LENGTH) {

        # Set max_length to 30 by default
        my $maxLength = shift || 30;
        $self->{maxLength} = $maxLength;
    }

    # is_optional - if true, field is only validated if it's not empty
    my $isOptional      = shift || 0;
    $self->{isOptional} = $isOptional;

    return $self;
}

#-----------------------------------------------------------------------------
# These methods should really be treated as private because the Form module
# handles calling these methods, for most purposes all you will need to know
# how to do is to instantiate FieldValidators.
#-----------------------------------------------------------------------------

# Checks to see what the validation type of the instance is and conditionally
# calls the appropriate validation method.
sub validate {
    my $self  = shift;
    my $input = shift; # User entered data

    # If the field is optional and is empty, don't validate
    return 1 if ($self->{isOptional} && !$input);

    if ($self->{validatorType} == WELL_FORMED_EMAIL) {

        return $self->_validateEmail($input);

    }
    elsif ($self->{validatorType} == MIN_STR_LENGTH) {

        return $self->_validateStrLength($input, $self->{minLength});

    }
    elsif ($self->{validatorType} == REGEX_MATCH) {

        return $self->_validateRegex($input, $self->{regex});

    }
    elsif ($self->{validatorType} == USER_DEFINED_SUB) {

        return $self->{usub}($input);

    }
    elsif ($self->{validatorType} == MAX_STR_LENGTH) {

        return $self->_validateMaxStrLength($input, $self->{maxLength});
    }
}

sub getFeedback {
    my $self = shift;
    return $self->{feedback};
}

*get_feedback = \&getFeedback;

# Checks to see if input is a well formed email address.
# TODO: Maybe use Email::Valid for this?
sub _validateEmail {
    my $self  = shift;
    my $input = shift || '';
    return ($input =~ /^[\w\-\.\+]+@([\w\-]+)(\.([\w\-]+))+$/);
}

# Checks to see if input is a minimum string length.
sub _validateStrLength {
    my $self   = shift;
    my $input  = shift;
    return (length($input) >= $self->{minLength});
}

sub _validateMaxStrLength {
    my $self  = shift;
    my $input = shift;
    return (length($input) <= $self->{maxLength});
}

# Checks to see if input matches the specified pattern.
sub _validateRegex {
    my $self  = shift;
    my $input = shift // '';

    return ($input =~ /$self->{regex}/);
}

1;

__END__