File Coverage

blib/lib/String/Validator/Common.pm

Criterion	Covered	Total	%
statement	88	88	100.0
branch	18	18	100.0
condition			n/a
subroutine	24	24	100.0
pod	16	16	100.0
total	146	146	100.0

package String::Validator::Common;
$String::Validator::Common::VERSION = '2.04'; # TRIAL
# ABSTRACT: Base Module for creating new String::Validator Modules.

use 5.008;
use strict;
use warnings;
no warnings 'uninitialized';
use Data::Printer;

my $common_messages = {
    common_strings_not_match => "Strings don\'t match.",
    common_tooshort          => "Does not meet requirement: Min Length ",
    common_toolong           => " Does not meet requirement: Max Length ",
};

sub _Messages {
    my $messages = {} ;
    for my $msg ( $common_messages, @_) {
        for my $c ( keys %{$msg} ) {
            $messages->{$c} = $msg->{$c};
        }
    }
    return $messages;
}

sub new {
    my $class = shift;
    my $self  = {@_};
    bless $self, $class;
    $self->{class} = $class;
    $self->{messages}
        = _Messages( $self->{language}, $self->{custom_messages} );
    $self->_Init();
    return $self;
}

sub IncreaseErr {
    my $self = shift;
    $self->{errstring} .= "@_\n";
    $self->{error}++;
}

# Every time we get a new request
# these values need to be reset from the
# previous request.
sub _Init {
    my $self = shift;
    $self->{errstring} = '';
    $self->{error}     = 0;
    $self->{string}    = '';
}

sub Start {
    my ( $self, $string1, $string2 ) = @_;
    $self->_Init();

    # String comparison, must not fail if no string2 is provided.
    # string2 is also available for destructive operations.
    # Failing the string match alse necessitates immediate
    # error return as the other tests are meaningless as
    # we cannot know if either or neither string is the password.
    no warnings 'uninitialized';
    if ( 0 == length $string2 ) { }
    elsif ( $string1 ne $string2 ) {
        $self->IncreaseErr( $self->{messages}{common_strings_not_match} );
        return 99;
    }
    $self->{string} = $string1;
    return 0;
}

sub Length {
    my $self   = shift;
    my $string = $self->{string};
    my $strlen = length( $self->{string} );
    if ( $strlen < $self->{min_len} ) {
        $self->IncreaseErr(
            $self->{messages}{common_tooshort} . $self->{min_len} );
        return $self->{error};
    }
    if ( $self->{max_len} ) {
        if ( $strlen > $self->{max_len} ) {
            $self->IncreaseErr(
                $self->{messages}{common_toolong} . $self->{max_len} );
            return $self->{error};
        }
    }
    return 0;
}

sub CheckCommon {
    my ( $self, $string1, $string2 ) = @_;
    if ( $self->Start( $string1, $string2 ) ) {
        return $self->{error};
    }
    if ( $self->Length ) { return $self->{error} }
    return 0;
}

# Check serves as example, but more importantly lets
# us test the module.
# Takes 2 strings and runs Start.
# If the strings match it returns 0, else 1.
sub Check {
    my ( $self, $string1, $string2 ) = @_;
    my $started = $self->Start( $string1, $string2 );
    return $self->{error};
}

sub Errcnt {
    my $self = shift;
    return $self->{error};
}

sub Errstr {
    my $self = shift;
    return $self->{errstring};
}

sub IsNot_Valid {
    ( my $self, my $string1, my $string2 ) = @_;
    if   ( $self->Check( $string1, $string2 ) ) { return $self->{errstring} }
    else                                        { return 0 }
}

sub Is_Valid {
    ( my $self, my $string1, my $string2 ) = @_;
    if   ( $self->Check( $string1, $string2 ) ) { return 0 }
    else                                        { return 1 }
}

sub String {
    my $self = shift;
    return $self->{string};
}

# The lowercase version of methods.
sub errcnt      { my $self = shift; $self->Errcnt( @_) }
sub errstr      { my $self = shift; $self->Errstr( @_) }
sub isnot_valid { my $self = shift; $self->IsNot_Valid( @_) }
sub is_valid    { my $self = shift; $self->Is_Valid( @_ ) }
sub string      { my $self = shift; $self->String( @_ ) }


1;    # End of String::Validator::Common

__END__