Data Validation

Dave Doyle
dave.s.doyle@gmail.com

OANDA Corp.

Data Validation

• We all do it at some point
• We do it to different degrees
• Many options but I'll look at two one
  • Params::Validate
  • Data::Schema -- I screwed up. I meant to write all this last night but got caught up in some last minute contract work. I can throw this before/after someone's talk next month if you like.
• Other options like:
  • Data::FormValidator
  • HTML::FormFu
  • Moose + MooseX::Declare

Params::Validate

• Meant to examine @_ in a sub
• by Dave Rolsky (prolific Perl Hacker)
• positional and named params
• basic type checks; regex checks; callback checks
• class checks; interface checks
• defaults values and optional params
• Carp::confess() on failure
• Not great for nested structs
• Unless otherwise specified, all arguements are required

Params::Validate - Positional

use Params::Validate qw(:all);

sub foo {
    #my $self = shift; # shift $self off first if OO
    my ($name, $age ) = validate_pos(@_,
        {
            type      => SCALAR,
            callbacks => {
                'min_length' => sub { return length($_[0]) >= 6;  },
                'max_length' => sub { return length($_[0]) <= 12; },
            },

        },
        { type => SCALAR, regex => qr/^\d+$/, optional => 1 },
    );
    print $name, '; $age ', (defined $age ? '' : 'not ' ), "defined.\n";
}

foo('yeehaw' );        #> yeehaw; age not defined
foo('yeehaw', 1);      #> yeehaw; age defined
foo("yaaaaay", 'i');   # fails regex check
foo("short" );         # fails min_length check
foo("looooooooooong"); # fails max_length check
foo([]);               # fails type check
foo(undef);            # fails type check
    

Params::Validate - Named

use Params::Validate qw(:all);

sub foo {
    #my $self = shift; # shift $self off first if OO
    my %args = validate(@_, {

        name => { type => SCALAR, regex => qr/^.{6,12}$/s },
        age  => { type => SCALAR, regex => qr/^\d+$/, optional => 1 },
    });
    print $args{name},
        '; age ',
        (defined $args{age} ? '' : 'not ' ),
        "defined.\n";
}

foo( name => 'yeehaw' );               #> yeehaw; age not defined
foo( name => 'yeehaw' );               #> yeehaw; age not defined
# unrolls if passed a hashref
foo( { name => 'yeehaw', age => 1 } ); #> yeehaw; age defined
    

Params::Validate - basic checks

• type - can be SCALAR, ARRAYREF, HASHREF, CODEREF, GLOB, GLOBREF, SCALARREF, UNDEF, OBJECT, BOOLEAN, HANDLE
• These types are exported with qw(:all) but you can specify a list
• If you import these, you cannot use Contextual::Return
• You can OR them together to allow multiple types:
• SCALAR | UNDEF (to allow for an undef value)
• BOOLEAN is actually a shortcute for SCALAR | UNDEF
• HANDLE is actually a shortcut for GLOB | GLOBREF

Params::Validate - types of checks

• regex - regex => qr/^\d+$/ - compare value against regular expression
• isa - isa => 'CGI::Application' - class validation; verify that the parameter is a class or subclass of the supplied arguement; can also be an arrayref of names
• can - can => 'bar' - interface validation; verify that the parameter can perform a certain method; again, you can do an arrayref of method names

Params::Validate - types of checks

• callbacks - a hashref of key/anonymous subs; write a custom validator; the parameter is passed into @_
• untaint - untaint => 1 - for running in a tainted environment; untaint the data
• default - provide a default value; if nothing passed in, will insert this value

Params::Validate - types of checks

• optional - optional => 1 - by default, each parameter is considered required; this makes them optional (when using positional validation, optional parameters must be after all required parameters)
• Note, that type => SCALAR | UNDEF is not the same as optional.
• If you do not specify optional and don't pass in the parameter at all, despite the fact that it may be undef, it will fail validation because the element was not found at all
• You would still have to explicitly pass the parameter

Params::Validate - types of checks

• depends - depends => [qw/other parameter names/] - dependancies
• If you specify a paramater as being optional => 1 but you wish it to become required if another optional parameter is entered, use this
• If using validate (named parameters) you do this by providing a list of the names of the parameters it depends on
• I've never used this using validate_pos although there is a way to do it; possibly by the index of the required element

Params::Validate - validate_with

  my %p =
      validate_with
          ( params => \@_,
            spec   => { foo => { type => SCALAR },
                        bar => { default => 10 } },
            allow_extra => 1,
            called => 'The Quux::Baz class constructor',
          );

  my @p =
      validate_with
          ( params => \@_,
            spec   => [ { type => SCALAR },
                        { default => 10 } ],
            allow_extra => 1,
            called => 'The Quux::Baz class constructor',
          );
    

Thank you.