File Coverage

blib/lib/Params/Check/Faster.pm

Criterion	Covered	Total	%
statement	155	168	92.2
branch	66	82	80.4
condition	35	51	68.6
subroutine	15	15	100.0
pod	3	3	100.0
total	274	319	85.8

package Params::Check::Faster;

use 5.006; #warnings.pm
use strict;

use Carp                        qw[carp croak];
use Locale::Maketext::Simple    Style => 'gettext';

BEGIN {
    use Exporter    ();
    use vars        qw[ @ISA $VERSION @EXPORT_OK $VERBOSE $ALLOW_UNKNOWN
                        $STRICT_TYPE $STRIP_LEADING_DASHES $NO_DUPLICATES
                        $PRESERVE_CASE $ONLY_ALLOW_DEFINED $WARNINGS_FATAL
                        $SANITY_CHECK_TEMPLATE $CALLER_DEPTH $_ERROR_STRING
                    ];

    @ISA        =   qw[ Exporter ];
    @EXPORT_OK  =   qw[check allow last_error];

    $VERSION                = '0.03';
    $VERBOSE                = $^W ? 1 : 0;
    $NO_DUPLICATES          = 0;
    $STRIP_LEADING_DASHES   = 0;
    $STRICT_TYPE            = 0;
    $ALLOW_UNKNOWN          = 0;
    $PRESERVE_CASE          = 0;
    $ONLY_ALLOW_DEFINED     = 0;
    $SANITY_CHECK_TEMPLATE  = 1;
    $WARNINGS_FATAL         = 0;
    $CALLER_DEPTH           = 0;
}

my %known_keys = map { $_ => 1 }
                    qw| required allow default strict_type no_override
                        store defined |;

=pod

=head1 NAME

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

=head1 SYNOPSIS

    use Params::Check::Faster 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::Faster::last_error();


=head1 DESCRIPTION

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

This module is a faster reimplementation of Params::Check. It should be 100%
compatible. It might be merged with Params::Check at some point, after its author (kane) has reviewed it and is happy with merging it.

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

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

=over 4

=item *

Convert all keys to lowercase

=item *

Check if all required arguments have been provided

=item *

Set arguments that have not been provided to the default

=item *

Weed out arguments that are not supported and warn about them to the
user

=item *

Validate the arguments given by the user based on strings, regexes,
lists or even subroutines

=item *

Enforce type integrity if required

=back

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

=head1 Template

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

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

The following rules are available:

=over 4

=item default

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

=item required

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

=item strict_type

This does a C check on the argument provided. The C of the
argument must be the same as the C 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.

=item defined

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

=item no_override

This allows you to specify C 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 C data in one place; the
C template.

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

It works for arrays or hash reference too. You can write :

    my @array;
    my %hash;
    my $args = check(foo => { default => [ 1 ], store => \@array },
                     bar => { default => { answer => 42 }, store => \%hash },
                     $input);

And @array and %hash contains directly the corresponding array or hash dereferenced.


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

=item allow

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

See the C function for details.

=back

=head1 Functions

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

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

    use Params::Check::Faster qw[check];

or use its fully qualified name instead.

C takes a list of arguments, as follows:

=over 4

=item Template

This is a hashreference which contains a template as explained in the
C and C