NAME

SYNOPSIS

    use Params::Check qw[check allow last_error];

    sub fill_personal_info {
        my %hash = @_;
        my $x;

        my $tmpl = {
            firstname   => { required   => 1, defined => 1 },
            lastname    => { required   => 1, store => \$x },
            gender      => { required   => 1,
                             allow      => [qr/M/i, qr/F/i],
                           },
            married     => { allow      => [0,1] },
            age         => { default    => 21,
                             allow      => qr/^\d+$/,
                           },

            phone       => { allow => [ sub { return 1 if /$valid_re/ },
                                        '1-800-PERL' ]
                           },
            id_list     => { default        => [],
                             strict_type    => 1
                           },
            employer    => { default => 'NSA', no_override => 1 },
        };

        ### check() returns a hashref of parsed args on success ###
        my $parsed_args = check( $tmpl, \%hash, $VERBOSE )
                            or die qw[Could not parse arguments!];

        ... other code here ...
    }

    my $ok = allow( $colour, [qw|blue green yellow|] );

    my $error = Params::Check::last_error();

DESCRIPTION

It allows you to validate input via a template. The only requirement is that the arguments must be named.

Params::Check can do the following things for you:

• Convert all keys to lowercase
• Check if all required arguments have been provided
• Set arguments that have not been provided to the default
• Weed out arguments that are not supported and warn about them to the user
• Validate the arguments given by the user based on strings, regexes, lists or even subroutines
• Enforce type integrity if required

Most of Params::Check's power comes from its template, which we'll discuss below:

Template

The template can take a different set of rules per key that is used.

The following rules are available:

default

This is the default value if none was provided by the user. This is also the type "strict_type" will look at when checking type integrity (see below).

required

A boolean flag that indicates if this argument was a required argument. If marked as required and not provided, check() will fail.

strict_type

This does a "ref()" check on the argument provided. The "ref" of the argument must be the same as the "ref" of the default value for this check to pass.

This is very useful if you insist on taking an array reference as argument for example.

defined

If this template key is true, enforces that if this key is provided by user input, its value is "defined". This just means that the user is not allowed to pass "undef" as a value for this key and is equivalent to: allow => sub { defined $_[0] && OTHER TESTS }

no_override

This allows you to specify "constants" in your template. ie, they keys that are not allowed to be altered by the user. It pretty much allows you to keep all your "configurable" data in one place; the "Params::Check" template.

store

This allows you to pass a reference to a scalar, in which the data will be stored:

    my $x;
    my $args = check(foo => { default => 1, store => \$x }, $input);
    

This is basically shorthand for saying:

    my $args = check( { foo => { default => 1 }, $input );
    my $x    = $args->{foo};
    

You can alter the global variable $Params::Check::NO_DUPLICATES to control whether the "store"'d key will still be present in your result set. See the "Global Variables" section below.

allow

A set of criteria used to validate a particular piece of data if it has to adhere to particular rules.

See the "allow()" function for details.

Functions

    use Params::Check qw[check];

    my $parsed = check( \%template, \%arguments, $VERBOSE )
                    or warn q[Arguments could not be parsed!];

Global Variables

    function( -key => 'val' );

    sub check {
        my ($template, $args_in) = @_;

        local $Params::Check::WARNINGS_FATAL = 1;
        local $Params::Check::CALLER_DEPTH = $Params::Check::CALLER_DEPTH + 1;
        my $args_out = Params::Check::check($template, $args_in);

        my_stacktrace(Params::Check::last_error) unless $args_out;

        return $args_out;
    }

Acknowledgements

BUG REPORTS

AUTHOR

COPYRIGHT