File Coverage

blib/lib/Params/Dry/Types.pm

Criterion	Covered	Total	%
statement	36	36	100.0
branch	16	18	88.8
condition	7	9	77.7
subroutine	13	13	100.0
pod	5	5	100.0
total	77	81	95.0

#!/usr/bin/perl
#*
#* Name: Params::Dry::Types
#* Info: Types definitions module
#* Author: Pawel Guspiel (neo77)
#*
#* This module keeps validation functions. You can of course add your modules which uses this and will add additional checks
#* Build in types for Params::Dry
#*
package Params::Dry::Types;
{
    use strict;
    use warnings;
    use utf8;

# --- version ---
    our $VERSION = 1.20_01;

#=------------------------------------------------------------------------ { use, constants }

    use Scalar::Util 'blessed';

    use constant PASS => 1;    # pass test
    use constant FAIL => 0;    # test fail

#=------------------------------------------------------------------------ { export }

    use Exporter;              # to export _ rq and opt
    our @ISA = qw(Exporter);

    our @EXPORT_OK = qw(PASS FAIL);

    our %EXPORT_TAGS = ( const => [qw(PASS FAIL)], );

#=------------------------------------------------------------------------ { module public functions }

    #=---------
    #  String
    #=---------
    #* string type check (parameter sets max length)
    #* RETURN: PASS if test pass otherwise FAIL
    sub String {
        ref( $_[0] ) and return FAIL;
        $_[1] and length $_[0] > $_[1] and return FAIL;
        PASS;
    } #+ end of: sub String

    #=---------
    #  Object
    #=---------
    #* Object type check, Object - just object, or Object(Params::Dry::Types) check if is Params::Dry::Types type
    #* RETURN: PASS if test pass otherwise FAIL
    sub Object {
        my $class = blessed( $_[0] );
        return FAIL if !$class;                         # not an object
        return FAIL if $_[1] and ( $_[1] ne $class );
        PASS;
    } #+ end of: sub Object

    #=------
    #  Ref
    #=------
    #* ref type check
    #* RETURN: PASS if test pass otherwise FAIL
    sub Ref {
        my $ref = ref( $_[0] ) or return FAIL;

        return FAIL if $_[1] and $ref ne $_[1];
        PASS;
    } #+ end of: sub Ref

    #=----------
    #  Defined
    #=----------
    #* Allows anything what is defined
    #* RETURN: PASS if defined
    sub Defined {
        defined $_[0] ? PASS : FAIL;
    } #+ end of: sub Defined

    #=--------
    #  Value
    #=--------
    #* Allows anything what is not a reference
    #* RETURN: PASS if defined
    sub Value {
        $_[0] and ref $_[0] ? FAIL : PASS;
    } #+ end of: sub Value

    {
        no warnings 'once';

        #+ Number - mapped types
        *Params::Dry::Types::Int   = *Params::Dry::Types::Number::Int;
        *Params::Dry::Types::Float = *Params::Dry::Types::Number::Float;
        *Params::Dry::Types::Bool  = *Params::Dry::Types::Number::Bool;

        #+ Ref - mapped types
        *Params::Dry::Types::Scalar = *Params::Dry::Types::Ref::Scalar;
        *Params::Dry::Types::Array  = *Params::Dry::Types::Ref::Array;
        *Params::Dry::Types::Hash   = *Params::Dry::Types::Ref::Hash;
        *Params::Dry::Types::Code   = *Params::Dry::Types::Ref::Code;
        *Params::Dry::Types::Regexp = *Params::Dry::Types::Ref::Regexp;
    };

};
0115 && 0x4d;

#+ End of Params::Dry::Types
__END__