use Types::Standard qw( Int Str );
use Params::ValidationCompiler qw( validation_for );
{
my $validator = validation_for(
params => {
foo => { type => Int },
bar => {
type => Str,
optional => 1,
},
baz => {
type => Int,
default => 42,
},
},
);
sub foo {
my %args = $validator->(@_);
}
}
{
my $validator = validation_for(
params => [
{ type => Int },
{
type => Str,
optional => 1,
},
],
);
sub bar {
my ( $int, $str ) = $validator->(@_);
}
}
{
my $validator = validation_for(
params => [
foo => { type => Int },
bar => {
type => Str,
optional => 1,
},
],
named_to_list => 1,
);
sub baz {
my ( $foo, $bar ) = $validator->(@_);
}
}
In addition to type checks, it also supports parameter defaults, optional parameters, and extra ``slurpy'' parameters.
If you pass a hashref then the generated validator sub will expect named parameters. The "params" value should be a hashref where the parameter names are keys and the specs are the values.
If you pass an arrayref and "named_to_list" is false, the validator will expect positional params. Each element of the "params" arrayref should be a parameter spec.
If you pass an arrayref and "named_to_list" is true, the validator will expect named params, but will return a list of values. In this case the arrayref should contain a list of key/value pairs, where parameter names are the keys and the specs are the values.
Each spec can contain either a boolean or hashref. If the spec is a boolean, this indicates required (true) or optional (false).
The spec hashref accepts the following keys:
A type object. This can be a Moose type (from Moose or MooseX::Types), a Type::Tiny type, or a Specio type.
If the type has coercions, those will always be used.
This can either be a simple (non-reference) scalar or a subroutine reference. The sub ref will be called without any arguments (for now).
A boolean indicating whether or not the parameter is optional. By default, parameters are required unless you provide a default.
You can also pass a type constraint here, in which case all extra arguments must be values of the specified type.
You cannot combine "slurpy" with "named_to_list" as there is no way to know how to order the extra return values.
The object's methods correspond to the parameter names passed to the subroutine. While calling methods on an object is slower than accessing a hashref, the advantage is that if you typo a parameter name you'll get a helpful error.
If you have Class::XSAccessor installed then this will be used to create the class's methods, which makes it fairly fast.
The returned object is in a generated class. Do not rely on this class name being anything in specific, and don't check this object using "isa", "DOES", or anything similar.
When "return_object" is true, the parameter spec hashref also accepts to the following additional keys:
Use this to set an explicit getter method name for the parameter. By default the method name will be the same as the parameter name. Note that if the parameter name is not a valid sub name, then you will get an error compiling the validation sub unless you specify a getter for the parameter.
Use this to ask for a predicate method to be created for this parameter. The predicate method returns true if the parameter was passed and false if it wasn't. Note that this is only useful for optional parameters, but you can ask for a predicate for any parameter.
For validators expected named params, the generated subroutine accepts either a list of key-value pairs or a single hashref. Otherwise the validator expects a list of values.
For now, you must shift off the invocant yourself.
This subroutine accepts the following additional parameters:
If this is given, then the generated subroutine will be named using Sub::Util. This is strongly recommended as it makes it possible to distinguish different check subroutines when profiling or in stack traces.
This name will also be used in some exception messages, even if Sub::Util is not available.
Note that you must install Sub::Util yourself separately, as it is not required by this distribution, in order to avoid requiring a compiler.
If this is true, then the name is ignored when "Sub::Util" is not installed. If this is false, then passing a name when Sub::Util cannot be loaded causes an exception.
This is useful for CPAN modules where you want to set a name if you can, but you do not want to add a prerequisite on Sub::Util.
Sets the "EVAL_CLOSURE_PRINT_SOURCE" environment variable to true before calling "Eval::Closure::eval_closure()". This causes the source of the subroutine to be printed before it's "eval"'d.
I am also usually active on IRC as 'autarch' on "irc://irc.perl.org".
Please note that I am not suggesting that you must do this 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.
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 (let's all have a chuckle at that together).
To donate, log into PayPal and send money to autarch@urth.org, or use the button at <http://www.urth.org/~autarch/fs-donation.html>.
This is free software, licensed under:
The Artistic License 2.0 (GPL Compatible)
The full text of the license can be found in the LICENSE file included with this distribution.