Add built local::lib

[catagits/Gitalist.git] / local-lib5 / man / man3 / Params::Validate.3pm

.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.3
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sh \" Subsection heading
.br
.if t .Sp
.ne 5
.PP
\fB\\$1\fR
.PP
..
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings.  \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote.  | will give a
.\" real vertical bar.  \*(C+ will give a nicer C++.  Capital omega is used to
.\" do unbreakable dashes and therefore won't be available.  \*(C` and \*(C'
.\" expand to `' in nroff, nothing in troff, for use with C<>.
.tr \(*W-|\(bv\*(Tr
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
.    ds -- \(*W-
.    ds PI pi
.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
.    ds L" ""
.    ds R" ""
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds -- \|\(em\|
.    ds PI \(*p
.    ds L" ``
.    ds R" ''
'br\}
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.if \nF \{\
.    de IX
.    tm Index:\\$1\t\\n%\t"\\$2"
..
.    nr % 0
.    rr F
.\}
.\"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.hy 0
.if n .na
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear.  Run.  Save yourself.  No user-serviceable parts.
.    \" fudge factors for nroff and troff
.if n \{\
.    ds #H 0
.    ds #V .8m
.    ds #F .3m
.    ds #[ \f1
.    ds #] \fP
.\}
.if t \{\
.    ds #H ((1u-(\\\\n(.fu%2u))*.13m)
.    ds #V .6m
.    ds #F 0
.    ds #[ \&
.    ds #] \&
.\}
.    \" simple accents for nroff and troff
.if n \{\
.    ds ' \&
.    ds ` \&
.    ds ^ \&
.    ds , \&
.    ds ~ ~
.    ds /
.\}
.if t \{\
.    ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
.    ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
.    ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
.    ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
.    ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
.    ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
.    \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
.    \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
.    \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
.    ds : e
.    ds 8 ss
.    ds o a
.    ds d- d\h'-1'\(ga
.    ds D- D\h'-1'\(hy
.    ds th \o'bp'
.    ds Th \o'LP'
.    ds ae ae
.    ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "Params::Validate 3"
.TH Params::Validate 3 "2009-12-09" "perl v5.8.7" "User Contributed Perl Documentation"
.SH "NAME"
Params::Validate \- Validate method/function parameters
.SH "SYNOPSIS"
.IX Header "SYNOPSIS"
.Vb 1
\&  use Params::Validate qw(:all);
.Ve
.PP
.Vb 8
\&  # takes named params (hash or hashref)
\&  sub foo
\&  {
\&      validate( @_, { foo => 1, # mandatory
\&                      bar => 0, # optional
\&                    }
\&              );
\&  }
.Ve
.PP
.Vb 6
\&  # takes positional params
\&  sub bar
\&  {
\&      # first two are mandatory, third is optional
\&      validate_pos( @_, 1, 1, 0 );
\&  }
.Ve
.PP
.Vb 6
\&  sub foo2
\&  {
\&      validate( @_,
\&                { foo =>
\&                  # specify a type
\&                  { type => ARRAYREF },
.Ve
.PP
.Vb 3
\&                  bar =>
\&                  # specify an interface
\&                  { can => [ 'print', 'flush', 'frobnicate' ] },
.Ve
.PP
.Vb 12
\&                  baz =>
\&                  { type => SCALAR,   # a scalar ...
\&                    # ... that is a plain integer ...
\&                    regex => qr/^\ed+$/,
\&                    callbacks =>
\&                    { # ... and smaller than 90
\&                      'less than 90' => sub { shift() < 90 },
\&                    },
\&                  }
\&                }
\&              );
\&  }
.Ve
.PP
.Vb 7
\&  sub with_defaults
\&  {
\&       my %p = validate( @_, { foo => 1, # required
\&                               # $p{bar} will be 99 if bar is not
\&                               # given.  bar is now optional.
\&                               bar => { default => 99 } } );
\&  }
.Ve
.PP
.Vb 4
\&  sub pos_with_defaults
\&  {
\&       my @p = validate_pos( @_, 1, { default => 99 } );
\&  }
.Ve
.PP
.Vb 8
\&  sub sets_options_on_call
\&  {
\&       my %p = validate_with
\&                   ( params => \e@_,
\&                     spec   => { foo => { type SCALAR, default => 2 } },
\&                     normalize_keys => sub { $_[0] =~ s/^\-//; lc $_[0] },
\&                   );
\&  }
.Ve
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
The Params::Validate module allows you to validate method or function
call parameters to an arbitrary level of specificity.  At the simplest
level, it is capable of validating the required parameters were given
and that no unspecified additional parameters were passed in.
.PP
It is also capable of determining that a parameter is of a specific
type, that it is an object of a certain class hierarchy, that it
possesses certain methods, or applying validation callbacks to
arguments.
.Sh "\s-1EXPORT\s0"
.IX Subsection "EXPORT"
The module always exports the \f(CW\*(C`validate()\*(C'\fR and \f(CW\*(C`validate_pos()\*(C'\fR
functions.
.PP
It also has an additional function available for export,
\&\f(CW\*(C`validate_with\*(C'\fR, which can be used to validate any type of
parameters, and set various options on a per-invocation basis.
.PP
In addition, it can export the following constants, which are used as
part of the type checking.  These are \f(CW\*(C`SCALAR\*(C'\fR, \f(CW\*(C`ARRAYREF\*(C'\fR,
\&\f(CW\*(C`HASHREF\*(C'\fR, \f(CW\*(C`CODEREF\*(C'\fR, \f(CW\*(C`GLOB\*(C'\fR, \f(CW\*(C`GLOBREF\*(C'\fR, and \f(CW\*(C`SCALARREF\*(C'\fR,
\&\f(CW\*(C`UNDEF\*(C'\fR, \f(CW\*(C`OBJECT\*(C'\fR, \f(CW\*(C`BOOLEAN\*(C'\fR, and \f(CW\*(C`HANDLE\*(C'\fR.  These are explained
in the section on Type Validation.
.PP
The constants are available via the export tag \f(CW\*(C`:types\*(C'\fR.  There is
also an \f(CW\*(C`:all\*(C'\fR tag which includes all of the constants as well as the
\&\f(CW\*(C`validation_options()\*(C'\fR function.
.SH "PARAMETER VALIDATION"
.IX Header "PARAMETER VALIDATION"
The validation mechanisms provided by this module can handle both
named or positional parameters.  For the most part, the same features
are available for each.  The biggest difference is the way that the
validation specification is given to the relevant subroutine.  The
other difference is in the error messages produced when validation
checks fail.
.PP
When handling named parameters, the module will accept either a hash
or a hash reference.
.PP
Subroutines expecting named parameters should call the \f(CW\*(C`validate()\*(C'\fR
subroutine like this:
.PP
.Vb 4
\& validate( @_, { parameter1 => validation spec,
\&                 parameter2 => validation spec,
\&                 ...
\&               } );
.Ve
.PP
Subroutines expecting positional parameters should call the
\&\f(CW\*(C`validate_pos()\*(C'\fR subroutine like this:
.PP
.Vb 1
\& validate_pos( @_, { validation spec }, { validation spec } );
.Ve
.Sh "Mandatory/Optional Parameters"
.IX Subsection "Mandatory/Optional Parameters"
If you just want to specify that some parameters are mandatory and
others are optional, this can be done very simply.
.PP
For a subroutine expecting named parameters, you would do this:
.PP
.Vb 1
\& validate( @_, { foo => 1, bar => 1, baz => 0 } );
.Ve
.PP
This says that the \*(L"foo\*(R" and \*(L"bar\*(R" parameters are mandatory and that
the \*(L"baz\*(R" parameter is optional.  The presence of any other
parameters will cause an error.
.PP
For a subroutine expecting positional parameters, you would do this:
.PP
.Vb 1
\& validate_pos( @_, 1, 1, 0, 0 );
.Ve
.PP
This says that you expect at least 2 and no more than 4 parameters.
If you have a subroutine that has a minimum number of parameters but
can take any maximum number, you can do this:
.PP
.Vb 1
\& validate_pos( @_, 1, 1, (0) x (@_ \- 2) );
.Ve
.PP
This will always be valid as long as at least two parameters are
given.  A similar construct could be used for the more complex
validation parameters described further on.
.PP
Please note that this:
.PP
.Vb 1
\& validate_pos( @_, 1, 1, 0, 1, 1 );
.Ve
.PP
makes absolutely no sense, so don't do it.  Any zeros must come at the
end of the validation specification.
.PP
In addition, if you specify that a parameter can have a default, then
it is considered optional.
.Sh "Type Validation"
.IX Subsection "Type Validation"
This module supports the following simple types, which can be
exported as constants:
.IP "* \s-1SCALAR\s0" 4
.IX Item "SCALAR"
A scalar which is not a reference, such as \f(CW10\fR or \f(CW'hello'\fR.  A
parameter that is undefined is \fBnot\fR treated as a scalar.  If you
want to allow undefined values, you will have to specify \f(CW\*(C`SCALAR |
UNDEF\*(C'\fR.
.IP "* \s-1ARRAYREF\s0" 4
.IX Item "ARRAYREF"
An array reference such as \f(CW\*(C`[1, 2, 3]\*(C'\fR or \f(CW\*(C`\e@foo\*(C'\fR.
.IP "* \s-1HASHREF\s0" 4
.IX Item "HASHREF"
A hash reference such as \f(CW\*(C`{ a => 1, b => 2 }\*(C'\fR or \f(CW\*(C`\e%bar\*(C'\fR.
.IP "* \s-1CODEREF\s0" 4
.IX Item "CODEREF"
A subroutine reference such as \f(CW\*(C`\e&foo_sub\*(C'\fR or \f(CW\*(C`sub { print "hello" }\*(C'\fR.
.IP "* \s-1GLOB\s0" 4
.IX Item "GLOB"
This one is a bit tricky.  A glob would be something like \f(CW*FOO\fR, but
not \f(CW\*(C`\e*FOO\*(C'\fR, which is a glob reference.  It should be noted that this
trick:
.Sp
.Vb 1
\& my $fh = do { local *FH; };
.Ve
.Sp
makes \f(CW$fh\fR a glob, not a glob reference.  On the other hand, the
return value from \f(CW\*(C`Symbol::gensym\*(C'\fR is a glob reference.  Either can
be used as a file or directory handle.
.IP "* \s-1GLOBREF\s0" 4
.IX Item "GLOBREF"
A glob reference such as \f(CW\*(C`\e*FOO\*(C'\fR.  See the \s-1GLOB\s0 entry above
for more details.
.IP "* \s-1SCALARREF\s0" 4
.IX Item "SCALARREF"
A reference to a scalar such as \f(CW\*(C`\e$x\*(C'\fR.
.IP "* \s-1UNDEF\s0" 4
.IX Item "UNDEF"
An undefined value
.IP "* \s-1OBJECT\s0" 4
.IX Item "OBJECT"
A blessed reference.
.IP "* \s-1BOOLEAN\s0" 4
.IX Item "BOOLEAN"
This is a special option, and is just a shortcut for \f(CW\*(C`UNDEF | SCALAR\*(C'\fR.
.IP "* \s-1HANDLE\s0" 4
.IX Item "HANDLE"
This option is also special, and is just a shortcut for \f(CW\*(C`GLOB |
GLOBREF\*(C'\fR.  However, it seems likely that most people interested in
either globs or glob references are likely to really be interested in
whether the parameter in question could be a valid file or directory
handle.
.PP
To specify that a parameter must be of a given type when using named
parameters, do this:
.PP
.Vb 2
\& validate( @_, { foo => { type => SCALAR },
\&                 bar => { type => HASHREF } } );
.Ve
.PP
If a parameter can be of more than one type, just use the bitwise or
(\f(CW\*(C`|\*(C'\fR) operator to combine them.
.PP
.Vb 1
\& validate( @_, { foo => { type => GLOB | GLOBREF } );
.Ve
.PP
For positional parameters, this can be specified as follows:
.PP
.Vb 1
\& validate_pos( @_, { type => SCALAR | ARRAYREF }, { type => CODEREF } );
.Ve
.Sh "Interface Validation"
.IX Subsection "Interface Validation"
To specify that a parameter is expected to have a certain set of
methods, we can do the following:
.PP
.Vb 4
\& validate( @_,
\&           { foo =>
\&             # just has to be able to \->bar
\&             { can => 'bar' } } );
.Ve
.PP
.Vb 1
\& ... or ...
.Ve
.PP
.Vb 4
\& validate( @_,
\&           { foo =>
\&             # must be able to \->bar and \->print
\&             { can => [ qw( bar print ) ] } } );
.Ve
.Sh "Class Validation"
.IX Subsection "Class Validation"
A word of warning.  When constructing your external interfaces, it is
probably better to specify what methods you expect an object to
have rather than what class it should be of (or a child of).  This
will make your \s-1API\s0 much more flexible.
.PP
With that said, if you want to validate that an incoming parameter
belongs to a class (or child class) or classes, do:
.PP
.Vb 3
\& validate( @_,
\&           { foo =>
\&             { isa => 'My::Frobnicator' } } );
.Ve
.PP
.Vb 1
\& ... or ...
.Ve
.PP
.Vb 4
\& validate( @_,
\&           { foo =>
\&             { isa => [ qw( My::Frobnicator IO::Handle ) ] } } );
\& # must be both, not either!
.Ve
.Sh "Regex Validation"
.IX Subsection "Regex Validation"
If you want to specify that a given parameter must match a specific
regular expression, this can be done with \*(L"regex\*(R" spec key.  For
example:
.PP
.Vb 3
\& validate( @_,
\&           { foo =>
\&             { regex => qr/^\ed+$/ } } );
.Ve
.PP
The value of the \*(L"regex\*(R" key may be either a string or a pre-compiled
regex created via \f(CW\*(C`qr\*(C'\fR.
.PP
If the value being checked against a regex is undefined, the regex is
explicitly checked against the empty string ('') instead, in order to
avoid \*(L"Use of uninitialized value\*(R" warnings.
.PP
The \f(CW\*(C`Regexp::Common\*(C'\fR module on \s-1CPAN\s0 is an excellent source of regular
expressions suitable for validating input.
.Sh "Callback Validation"
.IX Subsection "Callback Validation"
If none of the above are enough, it is possible to pass in one or more
callbacks to validate the parameter.  The callback will be given the
\&\fBvalue\fR of the parameter as its first argument.  Its second argument
will be all the parameters, as a reference to either a hash or array.
Callbacks are specified as hash reference.  The key is an id for the
callback (used in error messages) and the value is a subroutine
reference, such as:
.PP
.Vb 6
\& validate( @_,
\&           { foo =>
\&             { callbacks =>
\&               { 'smaller than a breadbox' => sub { shift() < $breadbox },
\&                 'green or blue' =>
\&                  sub { $_[0] eq 'green' || $_[0] eq 'blue' } } } );
.Ve
.PP
.Vb 4
\& validate( @_,
\&           { foo =>
\&             { callbacks =>
\&               { 'bigger than baz' => sub { $_[0] > $_[1]\->{baz} } } } } );
.Ve
.Sh "Untainting"
.IX Subsection "Untainting"
If you want values untainted, set the \*(L"untaint\*(R" key in a spec hashref
to a true value, like this:
.PP
.Vb 5
\& my %p =
\&   validate( @_, { foo =>
\&                   { type => SCALAR, untaint => 1 },
\&                   bar =>
\&                   { type => ARRAYREF } } );
.Ve
.PP
This will untaint the \*(L"foo\*(R" parameter if the parameters are valid.
.PP
Note that untainting is only done if \fIall parameters\fR are valid.
Also, only the return values are untainted, not the original values
passed into the validation function.
.PP
Asking for untainting of a reference value will not do anything, as
\&\f(CW\*(C`Params::Validate\*(C'\fR will only attempt to untaint the reference itself.
.Sh "Mandatory/Optional Revisited"
.IX Subsection "Mandatory/Optional Revisited"
If you want to specify something such as type or interface, plus the
fact that a parameter can be optional, do this:
.PP
.Vb 4
\& validate( @_, { foo =>
\&                 { type => SCALAR },
\&                 bar =>
\&                 { type => ARRAYREF, optional => 1 } } );
.Ve
.PP
or this for positional parameters:
.PP
.Vb 1
\& validate_pos( @_, { type => SCALAR }, { type => ARRAYREF, optional => 1 } );
.Ve
.PP
By default, parameters are assumed to be mandatory unless specified as
optional.
.Sh "Dependencies"
.IX Subsection "Dependencies"
It also possible to specify that a given optional parameter depends on
the presence of one or more other optional parameters.
.PP
.Vb 9
\& validate( @_, { cc_number =>
\&                 { type => SCALAR, optional => 1,
\&                   depends => [ 'cc_expiration', 'cc_holder_name' ],
\&                 },
\&                 cc_expiration
\&                 { type => SCALAR, optional => 1 },
\&                 cc_holder_name
\&                 { type => SCALAR, optional => 1 },
\&               } );
.Ve
.PP
In this case, \*(L"cc_number\*(R", \*(L"cc_expiration\*(R", and \*(L"cc_holder_name\*(R" are
all optional.  However, if \*(L"cc_number\*(R" is provided, then
\&\*(L"cc_expiration\*(R" and \*(L"cc_holder_name\*(R" must be provided as well.
.PP
This allows you to group together sets of parameters that all must be
provided together.
.PP
The \f(CW\*(C`validate_pos()\*(C'\fR version of dependencies is slightly different,
in that you can only depend on one other parameter.  Also, if for
example, the second parameter 2 depends on the fourth parameter, then
it implies a dependency on the third parameter as well.  This is
because if the fourth parameter is required, then the user must also
provide a third parameter so that there can be four parameters in
total.
.PP
\&\f(CW\*(C`Params::Validate\*(C'\fR will die if you try to depend on a parameter not
declared as part of your parameter specification.
.Sh "Specifying defaults"
.IX Subsection "Specifying defaults"
If the \f(CW\*(C`validate()\*(C'\fR or \f(CW\*(C`validate_pos()\*(C'\fR functions are called in a
list context, they will return an array or hash containing the
original parameters plus defaults as indicated by the validation spec.
.PP
If the function is not called in a list context, providing a default
in the validation spec still indicates that the parameter is optional.
.PP
The hash or array returned from the function will always be a copy of
the original parameters, in order to leave \f(CW@_\fR untouched for the
calling function.
.PP
Simple examples of defaults would be:
.PP
.Vb 1
\& my %p = validate( @_, { foo => 1, bar => { default => 99 } } );
.Ve
.PP
.Vb 1
\& my @p = validate( @_, 1, { default => 99 } );
.Ve
.PP
In scalar context, a hash reference or array reference will be
returned, as appropriate.
.SH "USAGE NOTES"
.IX Header "USAGE NOTES"
.Sh "Validation failure"
.IX Subsection "Validation failure"
By default, when validation fails \f(CW\*(C`Params::Validate\*(C'\fR calls
\&\f(CW\*(C`Carp::confess()\*(C'\fR.  This can be overridden by setting the \f(CW\*(C`on_fail\*(C'\fR
option, which is described in the \*(L"\s-1GLOBAL\s0\*(R" \s-1OPTIONS\s0
section.
.Sh "Method calls"
.IX Subsection "Method calls"
When using this module to validate the parameters passed to a method
call, you will probably want to remove the class/object from the
parameter list \fBbefore\fR calling \f(CW\*(C`validate()\*(C'\fR or \f(CW\*(C`validate_pos()\*(C'\fR.
If your method expects named parameters, then this is necessary for
the \f(CW\*(C`validate()\*(C'\fR function to actually work, otherwise \f(CW@_\fR will not
be useable as a hash, because it will first have your object (or
class) \fBfollowed\fR by a set of keys and values.
.PP
Thus the idiomatic usage of \f(CW\*(C`validate()\*(C'\fR in a method call will look
something like this:
.PP
.Vb 3
\& sub method
\& {
\&     my $self = shift;
.Ve
.PP
.Vb 2
\&     my %params = validate( @_, { foo => 1, bar => { type => ARRAYREF } } );
\& }
.Ve
.ie n .SH """GLOBAL"" OPTIONS"
.el .SH "``GLOBAL'' OPTIONS"
.IX Header "GLOBAL OPTIONS"
Because the \s-1API\s0 for the \f(CW\*(C`validate()\*(C'\fR and \f(CW\*(C`validate_pos()\*(C'\fR functions
does not make it possible to specify any options other than the the
validation spec, it is possible to set some options as
pseudo\-'globals'.  These allow you to specify such things as whether
or not the validation of named parameters should be case sensitive,
for one example.
.PP
These options are called pseudo\-'globals' because these settings are
\&\fBonly applied to calls originating from the package that set the
options\fR.
.PP
In other words, if I am in package \f(CW\*(C`Foo\*(C'\fR and I call
\&\f(CW\*(C`validation_options()\*(C'\fR, those options are only in effect when I call
\&\f(CW\*(C`validate()\*(C'\fR from package \f(CW\*(C`Foo\*(C'\fR.
.PP
While this is quite different from how most other modules operate, I
feel that this is necessary in able to make it possible for one
module/application to use Params::Validate while still using other
modules that also use Params::Validate, perhaps with different
options set.
.PP
The downside to this is that if you are writing an app with a standard
calling style for all functions, and your app has ten modules, \fBeach
module must include a call to \f(CB\*(C`validation_options()\*(C'\fB\fR. You could of
course write a module that all your modules use which uses various
trickery to do this when imported.
.Sh "Options"
.IX Subsection "Options"
.ie n .IP "* normalize_keys => $callback" 4
.el .IP "* normalize_keys => \f(CW$callback\fR" 4
.IX Item "normalize_keys => $callback"
This option is only relevant when dealing with named parameters.
.Sp
This callback will be used to transform the hash keys of both the
parameters and the parameter spec when \f(CW\*(C`validate()\*(C'\fR or
\&\f(CW\*(C`validate_with()\*(C'\fR are called.
.Sp
Any alterations made by this callback will be reflected in the
parameter hash that is returned by the validation function.  For
example:
.Sp
.Vb 7
\&  sub foo {
\&      return
\&        validate_with( params => \e@_,
\&                       spec   => { foo => { type => SCALAR } },
\&                       normalize_keys =>
\&                       sub { my $k = shift; $k =~ s/^\-//; return uc $k },
\&                     );
.Ve
.Sp
.Vb 1
\&  }
.Ve
.Sp
.Vb 1
\&  %p = foo( foo => 20 );
.Ve
.Sp
.Vb 1
\&  # $p{FOO} is now 20
.Ve
.Sp
.Vb 1
\&  %p = foo( \-fOo => 50 );
.Ve
.Sp
.Vb 1
\&  # $p{FOO} is now 50
.Ve
.Sp
The callback must return a defined value.
.Sp
If a callback is given than the deprecated \*(L"ignore_case\*(R" and
\&\*(L"strip_leading\*(R" options are ignored.
.ie n .IP "* allow_extra => $boolean" 4
.el .IP "* allow_extra => \f(CW$boolean\fR" 4
.IX Item "allow_extra => $boolean"
If true, then the validation routine will allow extra parameters not
named in the validation specification.  In the case of positional
parameters, this allows an unlimited number of maximum parameters
(though a minimum may still be set).  Defaults to false.
.ie n .IP "* on_fail => $callback" 4
.el .IP "* on_fail => \f(CW$callback\fR" 4
.IX Item "on_fail => $callback"
If given, this callback will be called whenever a validation check
fails.  It will be called with a single parameter, which will be a
string describing the failure.  This is useful if you wish to have
this module throw exceptions as objects rather than as strings, for
example.
.Sp
This callback is expected to \f(CW\*(C`die()\*(C'\fR internally.  If it does not, the
validation will proceed onwards, with unpredictable results.
.Sp
The default is to simply use the Carp module's \f(CW\*(C`confess()\*(C'\fR function.
.ie n .IP "* stack_skip => $number" 4
.el .IP "* stack_skip => \f(CW$number\fR" 4
.IX Item "stack_skip => $number"
This tells Params::Validate how many stack frames to skip when finding
a subroutine name to use in error messages.  By default, it looks one
frame back, at the immediate caller to \f(CW\*(C`validate()\*(C'\fR or
\&\f(CW\*(C`validate_pos()\*(C'\fR.  If this option is set, then the given number of
frames are skipped instead.
.ie n .IP "* ignore_case => $boolean" 4
.el .IP "* ignore_case => \f(CW$boolean\fR" 4
.IX Item "ignore_case => $boolean"
\&\s-1DEPRECATED\s0
.Sp
This is only relevant when dealing with named parameters.  If it is
true, then the validation code will ignore the case of parameter
names.  Defaults to false.
.ie n .IP "* strip_leading => $characters" 4
.el .IP "* strip_leading => \f(CW$characters\fR" 4
.IX Item "strip_leading => $characters"
\&\s-1DEPRECATED\s0
.Sp
This too is only relevant when dealing with named parameters.  If this
is given then any parameters starting with these characters will be
considered equivalent to parameters without them entirely.  For
example, if this is specified as '\-', then \f(CW\*(C`\-foo\*(C'\fR and \f(CW\*(C`foo\*(C'\fR would be
considered identical.
.SH "PER-INVOCATION OPTIONS"
.IX Header "PER-INVOCATION OPTIONS"
The \f(CW\*(C`validate_with()\*(C'\fR function can be used to set the options listed
above on a per-invocation basis.  For example:
.PP
.Vb 7
\&  my %p =
\&      validate_with
\&          ( params => \e@_,
\&            spec   => { foo => { type => SCALAR },
\&                        bar => { default => 10 } },
\&            allow_extra => 1,
\&          );
.Ve
.PP
In addition to the options listed above, it is also possible to set
the option \*(L"called\*(R", which should be a string.  This string will be
used in any error messages caused by a failure to meet the validation
spec.
.PP
This subroutine will validate named parameters as a hash if the \*(L"spec\*(R"
parameter is a hash reference.  If it is an array reference, the
parameters are assumed to be positional.
.PP
.Vb 8
\&  my %p =
\&      validate_with
\&          ( params => \e@_,
\&            spec   => { foo => { type => SCALAR },
\&                        bar => { default => 10 } },
\&            allow_extra => 1,
\&            called => 'The Quux::Baz class constructor',
\&          );
.Ve
.PP
.Vb 8
\&  my @p =
\&      validate_with
\&          ( params => \e@_,
\&            spec   => [ { type => SCALAR },
\&                        { default => 10 } ],
\&            allow_extra => 1,
\&            called => 'The Quux::Baz class constructor',
\&          );
.Ve
.SH "DISABLING VALIDATION"
.IX Header "DISABLING VALIDATION"
If the environment variable \f(CW\*(C`PERL_NO_VALIDATION\*(C'\fR is set to something
true, then validation is turned off.  This may be useful if you only
want to use this module during development but don't want the speed
hit during production.
.PP
The only error that will be caught will be when an odd number of
parameters are passed into a function/method that expects a hash.
.PP
If you want to selectively turn validation on and off at runtime, you
can directly set the \f(CW$Params::Validate::NO_VALIDATION\fR global
variable.  It is \fBstrongly\fR recommended that you \fBlocalize\fR any
changes to this variable, because other modules you are using may
expect validation to be on when they execute.  For example:
.PP
.Vb 5
\&  {
\&      local $Params::Validate::NO_VALIDATION = 1;
\&      # no error
\&      foo( bar => 2 );
\&  }
.Ve
.PP
.Vb 2
\&  # error
\&  foo( bar => 2 );
.Ve
.PP
.Vb 5
\&  sub foo
\&  {
\&      my %p = validate( @_, { foo => 1 } );
\&      ...
\&  }
.Ve
.PP
But if you want to shoot yourself in the foot and just turn it off, go
ahead!
.SH "LIMITATIONS"
.IX Header "LIMITATIONS"
Right now there is no way (short of a callback) to specify that
something must be of one of a list of classes, or that it must possess
one of a list of methods.  If this is desired, it can be added in the
future.
.PP
Ideally, there would be only one validation function.  If someone
figures out how to do this, please let me know.
.SH "SUPPORT"
.IX Header "SUPPORT"
Please submit bugs and patches to the \s-1CPAN\s0 \s-1RT\s0 system at
http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Params%3A%3AValidate or
via email at bug\-params\-validate@rt.cpan.org.
.PP
Support questions can be sent to Dave at autarch@urth.org.
.PP
The code repository is at https://svn.urth.org/svn/Params\-Validate/
.SH "DONATIONS"
.IX Header "DONATIONS"
If you'd like to thank me for the work I've done on this module,
please consider making a \*(L"donation\*(R" to me via PayPal. I spend a lot of
free time creating free software, and would appreciate any support
you'd care to offer.
.PP
Please note that \fBI am not suggesting that you must do this\fR in order
for me to continue working on this particular software. I will
continue to do so, inasmuch as I have in the past, for as long as it
interests me.
.PP
Similarly, a donation made in this way will probably not make me work
on this software much more, unless I get so many donations that I can
consider working on free software full time, which seems unlikely at
best.
.PP
To donate, log into PayPal and send money to autarch@urth.org or use
the button on this page:
<http://www.urth.org/~autarch/fs\-donation.html>
.SH "AUTHORS"
.IX Header "AUTHORS"
Dave Rolsky, <autarch@urth.org> and Ilya Martynov <ilya@martynov.org>
.SH "COPYRIGHT"
.IX Header "COPYRIGHT"
Copyright (c) 2004\-2007 David Rolsky.  All rights reserved.  This
program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.