File Coverage

blib/lib/String/Validator/Password.pm

Criterion	Covered	Total	%
statement	72	72	100.0
branch	34	34	100.0
condition	6	6	100.0
subroutine	8	8	100.0
pod	2	2	100.0
total	122	122	100.0

package String::Validator::Password;
$String::Validator::Password::VERSION = '2.01'; # TRIAL
# ABSTRACT: String::Validator Password Checking Module.

use 5.008;
use strict;
use warnings;
no warnings qw(uninitialized) ;
use String::Validator::Common 2.00;


my $password_messages = {
	password_mintypes => sub {
		my $self = shift @_;
		return "Input contained $self->{types_found} types of character, $self->{min_types} are required.";
	},
	password_minoftype => sub {
		my ( $required, $type ) = @_;
		if ( $type eq 'num') { $type = 'numeric'}
		return "At least $required characters of type $type is required.";
	},
	password_typeprohibit => sub {
		my $type = shift @_;
		if ( $type eq 'num') { $type = 'numeric'}
		return "character type $type is prohibited."
	},
};

sub new {
    my $class = shift ;
    my $self = { @_ } ;
    use base ( 'String::Validator::Common' ) ;
    unless ( defined $self->{ require_lc } )     { $self->{ require_lc } = 0 };
    unless ( defined $self->{ require_uc } )     { $self->{ require_uc } = 0 };
    unless ( defined $self->{ require_num } )   { $self->{ require_num } = 0 };
    unless ( defined $self->{ require_punct } )  { $self->{ require_punct } = 0 };
    unless ( defined $self->{ deny_punct } ) 	 { $self->{ deny_punct } = 0 };
    unless ( defined $self->{ deny_lc } )        { $self->{ deny_lc } = 0 };
    unless ( defined $self->{ deny_uc } )        { $self->{ deny_uc } = 0 };
    unless ( defined $self->{ deny_num } )      { $self->{ deny_num } = 0 };
    unless ( defined $self->{ min_types } )	 	 { $self->{ min_types } = 2 };
    unless ( defined $self->{ min_len } )        { $self->{ min_len } = 6 };
    unless ( defined $self->{ max_len } )        { $self->{ max_len } = 64 };
# Not implemented right now.
#    unless ( defined $self->{ dictionary } )     { $self->{ dictionary } = [ 'default' ] }
#    unless ( defined $self->{ custom_allow } )   { $self->{ custom_allow } = 0 }
#    unless ( defined $self->{ custom_deny } )    { $self->{ custom_deny } = 0 }
    $self->{ string } = '' ;
    $self->{ error } = 0 ;
    $self->{errstring} = '' ;
    bless $self, $class ;
    $self->{messages}
        = String::Validator::Common::_Messages(
        		$password_messages, $self->{language}, $self->{custom_messages} );
    return $self ;
}

# Does all the checks and returns the
# number of errors found. Used by the
# Is/IsNot_Valid. May be invoked directly.
sub Check{
    my ( $self, $string1, $string2 ) = @_ ;
    if ( $self->Start( $string1, $string2 ) == 99 ) {
        return $self->{ error } }
    $self->Length;
# The match operator cannot be directly used to count matches.
# substitution does count replacements, and by removing all other
# other character classes what is left over is "punct".
	$string2 = $string1 ; # make sure string is in string2.
    $self->{num_lc} = $string2 =~ s/[a-z]//g || 0;
    $self->{num_uc} = $string2 =~ s/[A-Z]//g || 0 ;
    $self->{num_num} = $string2 =~ s/\d//g || 0;
    $self->{num_punct} = length $string2; #What is left is punct.
	$self->{ types_found } = 0;
    for ( qw / num_lc num_uc num_num num_punct / ) {
        if ( $self->{ $_ } ) { $self->{ types_found }++ }  }
	if ( $self->{types_found} < $self->{ min_types } ) {
		$self->IncreaseErr(
			$self->{messages}{password_mintypes}->( $self ));
		}
    foreach my $type ( qw /lc num uc punct/ ) {
		my $required = 'require_' . $type ;
		my $denied = 'deny_' . $type ;
		my $num = 'num_' . $type ;
		unless ( $self->{ $required } <= $self->{ $num } ) {
			$self->IncreaseErr(
				$self->{messages}{password_minoftype}->(
					$self->{ $required }, $type ) ) }
		if ( $self->{ $denied }  ) {
			if ( $self->{ $num } >= $self->{ $denied } )
				{ $self->IncreaseErr(
					$self->{messages}{password_typeprohibit}->($type) ) } }
	} #foreach ( lc num uc punct ).
return $self->{ error } ;
}


1; # End of Validator

__END__