SEARCH
NEW RPMS
DIRECTORIES
ABOUT
FAQ
VARIOUS
BLOG
DONATE


YUM REPOSITORY

 
 

MAN page from CentOS 6 psrk-perl-Params-Check-0.26-27.5.noarch.rpm

Params::Check

Section: Perl Programmers Reference Guide (3pm)
Updated: 2011-06-07
Index 

NAME

Params::Check - A generic input parsing/checking mechanism. 

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

Params::Check is a generic input parsing/checking mechanism.

It allows you to validate input via a template. The only requirementis 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 theuser
*
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'lldiscuss below: 

Template

As you can see in the synopsis, based on your template, the argumentsprovided will be validated.

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 typeintegrity (see below).
required
A boolean flag that indicates if this argument was a requiredargument. If marked as required and not provided, check() will fail.
strict_type
This does a "ref()" check on the argument provided. The "ref" of theargument must be the same as the "ref" of the default value for thischeck to pass.

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

defined
If this template key is true, enforces that if this key is provided byuser input, its value is "defined". This just means that the user isnot allowed to pass "undef" as a value for this key and is equivalentto:
    allow => sub { defined $_[0] && OTHER TESTS }
no_override
This allows you to specify "constants" in your template. ie, theykeys that are not allowed to be altered by the user. It pretty muchallows 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 datawill 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 tocontrol whether the "store"'d key will still be present in yourresult set. See the ``Global Variables'' section below.

allow
A set of criteria used to validate a particular piece of data if ithas to adhere to particular rules.

See the "allow()" function for details.

 

Functions

 

check( \%tmpl, \%args, [$verbose] );

This function is not exported by default, so you'll have to ask for itvia:

    use Params::Check qw[check];

or use its fully qualified name instead.

"check" takes a list of arguments, as follows:

Template
This is a hashreference which contains a template as explained in the"SYNOPSIS" and "Template" section.
Arguments
This is a reference to a hash of named arguments which need checking.
Verbose
A boolean to indicate whether "check" should be verbose and warnabout what went wrong in a check or not.

You can enable this program wide by setting the package variable$Params::Check::VERBOSE to a true value. For details, see thesection on "Global Variables" below.

"check" will return when it fails, or a hashref with lowercasekeys of parsed arguments when it succeeds.

So a typical call to check would look like this:

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

A lot of the behaviour of "check()" can be altered by settingpackage variables. See the section on "Global Variables" for detailson this. 

allow( $test_me, \@criteria );

The function that handles the "allow" key in the template is alsoavailable for independent use.

The function takes as first argument a key to test against, andas second argument any form of criteria that are also allowed bythe "allow" key in the template.

You can use the following types of values for allow:

string
The provided argument MUST be equal to the string for the validationto pass.
regexp
The provided argument MUST match the regular expression for thevalidation to pass.
subroutine
The provided subroutine MUST return true in order for the validationto pass and the argument accepted.

(This is particularly useful for more complicated data).

array ref
The provided argument MUST equal one of the elements of the arrayref for the validation to pass. An array ref can hold all the abovevalues.

It returns true if the key matched the criteria, or false otherwise. 

last_error()

Returns a string containing all warnings and errors reported duringthe last time "check" was called.

This is useful if you want to report then some other way than"carp"'ing when the verbose flag is on.

It is exported upon request. 

Global Variables

The behaviour of Params::Check can be altered by changing thefollowing global variables: 

$Params::Check::VERBOSE

This controls whether Params::Check will issue warnings andexplanations as to why certain things may have failed.If you set it to 0, Params::Check will not output any warnings.

The default is 1 when warnings are enabled, 0 otherwise; 

$Params::Check::STRICT_TYPE

This works like the "strict_type" option you can pass to "check",which will turn on "strict_type" globally for all calls to "check".

The default is 0; 

$Params::Check::ALLOW_UNKNOWN

If you set this flag, unknown options will still be present in thereturn value, rather than filtered out. This is useful if yoursubroutine is only interested in a few arguments, and wants to passthe rest on blindly to perhaps another subroutine.

The default is 0; 

$Params::Check::STRIP_LEADING_DASHES

If you set this flag, all keys passed in the following manner:

    function( -key => 'val' );

will have their leading dashes stripped. 

$Params::Check::NO_DUPLICATES

If set to true, all keys in the template that are marked as to bestored in a scalar, will also be removed from the result set.

Default is false, meaning that when you use "store" as a templatekey, "check" will put it both in the scalar you supplied, as well asin the hashref it returns. 

$Params::Check::PRESERVE_CASE

If set to true, Params::Check will no longer convert all keys fromthe user input to lowercase, but instead expect them to be in thecase the template provided. This is useful when you want to usesimilar keys with different casing in your templates.

Understand that this removes the case-insensitivy feature of thismodule.

Default is 0; 

$Params::Check::ONLY_ALLOW_DEFINED

If set to true, Params::Check will require all values passed to be"defined". If you wish to enable this on a 'per key' basis, use thetemplate option "defined" instead.

Default is 0; 

$Params::Check::SANITY_CHECK_TEMPLATE

If set to true, Params::Check will sanity check templates, validatingfor errors and unknown keys. Although very useful for debugging, thiscan be somewhat slow in hot-code and large loops.

To disable this check, set this variable to "false".

Default is 1; 

$Params::Check::WARNINGS_FATAL

If set to true, Params::Check will "croak" when an error during template validation occurs, rather than return "false".

Default is 0; 

$Params::Check::CALLER_DEPTH

This global modifies the argument given to "caller()" by"Params::Check::check()" and is useful if you have a custom wrapperfunction around "Params::Check::check()". The value must be aninteger, indicating the number of wrapper functions inserted betweenthe real function call and "Params::Check::check()".

Example wrapper function, using a custom stacktrace:

    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;    }

Default is 0; 

AUTHOR

This module byJos Boumans <kaneAATTcpan.org>. 

Acknowledgements

Thanks to Richard Soderberg for his performance improvements. 

COPYRIGHT

This module iscopyright (c) 2003,2004 Jos Boumans <kaneAATTcpan.org>.All rights reserved.

This library is free software;you may redistribute and/or modify it under the sameterms as Perl itself.


 

Index

NAME
SYNOPSIS
DESCRIPTION
Template
Functions
check( \%tmpl, \%args, [$verbose] );
allow( $test_me, \@criteria );
last_error()
Global Variables
$Params::Check::VERBOSE
$Params::Check::STRICT_TYPE
$Params::Check::ALLOW_UNKNOWN
$Params::Check::STRIP_LEADING_DASHES
$Params::Check::NO_DUPLICATES
$Params::Check::PRESERVE_CASE
$Params::Check::ONLY_ALLOW_DEFINED
$Params::Check::SANITY_CHECK_TEMPLATE
$Params::Check::WARNINGS_FATAL
$Params::Check::CALLER_DEPTH
AUTHOR
Acknowledgements
COPYRIGHT

This document was created byman2html,using the manual pages.