NAME
Validation::Class - Powerful Data Validation Framework
VERSION
version 7.900043
SYNOPSIS
use Validation::Class::Simple::Streamer;
my $parameters = {username => 'admin', password => 's3cret'};
my $input = Validation::Class::Simple::Streamer->new($parameters);
# check username parameter
$input->check('username')->required->between('5-255');
$input->filters([qw/trim strip/]);
# check password parameter
$input->check('password')->required->between('5-255')->min_symbols(1);
$input->filters([qw/trim strip/]);
# run validations
unless ($input) {
print $input->messages("\n");
}
DESCRIPTION
Validation::Class is a scalable data validation library with interfaces
for applications of all sizes.
The most common usage of Validation::Class is to transform class
namespaces into data validation domains where consistency and reuse are
primary concerns. Validation::Class provides an extensible framework for
defining reusable data validation rules. It ships with a complete set of
pre-defined validations and filters referred to as "directives".
The core feature-set consist of self-validating methods, validation
profiles, reusable validation rules and templates, pre and post input
filtering, class inheritance, automatic array handling, and
extensibility (e.g. overriding default error messages, creating custom
validators, creating custom input filters and much more).
Validation::Class promotes DRY (don't repeat yourself) code. The main
benefit in using Validation::Class is that the architecture is designed
to increase the consistency of data input handling. The following is a
more traditional usage of Validation::Class:
package MyApp::Person;
use Validation::Class;
# data validation template
mixin basic => {
required => 1,
max_length => 255,
filters => [qw/trim strip/]
};
# data validation rules for the username parameter
field username => {
mixin => 'basic',
min_length => 5
};
# data validation rules for the password parameter
field password => {
mixin => 'basic',
min_length => 5,
min_symbols => 1
};
package main;
my $person = MyApp::Person->new(username => 'admin', password => 'secr3t');
# validate rules on the person object
unless ($person->validates) {
# handle the failures
warn $person->errors_to_string;
}
1;
QUICKSTART
If you are looking for a simple in-line data validation module built
using the same tenets and principles as Validation::Class, please review
Validation::Class::Simple or Validation::Class::Simple::Streamer. If
you're interested in an experimental yet highly promising approach
toward validating hierarchical data, please take a moment to review
Validation::Class::Document.
RATIONALE
If you are new to Validation::Class, or would like more information on
the underpinnings of this library and how it views and approaches data
validation, please review Validation::Class::Whitepaper. Please review
the "GUIDED-TOUR" in Validation::Class::Simple for a detailed
step-by-step look into how Validation::Class works.
KEYWORDS
attribute
The attribute keyword (or has) registers a class attribute, i.e. it
creates an accessor (getter and setter) on the class. Attribute
declaration is flexible and only requires an attribute name to be
configured. Additionally, the attribute keyword can takes two arguments,
the attribute's name and a scalar or coderef to be used as it's default
value.
package MyApp::Person;
use Validate::Class;
has 'first_name' => 'Peter';
has 'last_name' => 'Venkman';
has 'full_name' => sub { join ', ', $_[0]->last_name, $_[0]->first_name };
has 'email_address';
1;
build
The build keyword (or bld) registers a coderef to be run at
instantiation much in the same way the common BUILD routine is used in
modern OO frameworks.
package MyApp::Person;
use Validation::Class;
build sub {
my ($self, $args) = @_;
# run after instantiation in the order defined
};
The build keyword takes one argument, a coderef which is passed the
instantiated class object.
directive
The directive keyword (or dir) registers custom validator directives to
be used in your field definitions. This is a means of extending the list
of directives per instance. See the list of core directives,
Validation::Class::Directives, or review Validation::Class::Directive
for insight into creating your own CPAN installable directives.
package MyApp::Person;
use Validate::Class;
# define a custom class-level directive
directive 'blacklisted' => sub {
my ($self, $field, $param) = @_;
if (defined $field->{blacklisted} && defined $param) {
if ($field->{required} || $param) {
if (exists_in_blacklist($field->{blacklisted}, $param)) {
my $handle = $field->label || $field->name;
$field->errors->add("$handle has been blacklisted");
return 0;
}
}
}
return 1;
};
field 'email_address' => {
blacklisted => '/path/to/blacklist'
email => 1,
};
1;
The directive keyword takes two arguments, the name of the directive and
a coderef which will be used to validate the associated field. The
coderef is passed four ordered parameters; a directive object, the class
prototype object, the current field object, and the matching parameter's
value. The validator (coderef) is evaluated by its return value as well
as whether it altered any error containers.
field
The field keyword (or fld) registers a data validation rule for reuse
and validation in code. The field name should correspond with the
parameter name expected to be passed to your validation class or
validated against.
package MyApp::Person;
use Validation::Class;
field 'username' => {
required => 1,
min_length => 1,
max_length => 255
};
The field keyword takes two arguments, the field name and a hashref of
key/values pairs known as directives. For more information on
pre-defined directives, please review the "list of core directives".
The field keyword also creates accessors which provide easy access to
the field's corresponding parameter value(s). Accessors will be created
using the field's name as a label having any special characters replaced
with an underscore.
# accessor will be created as send_reminders
field 'send-reminders' => {
length => 1
};
Please note that prefixing field names with a double plus-symbol
instructs the register to merge your declaration with any pre-existing
declarations within the same scope (e.g. fields imported via loading
roles), whereas prefixing field names with a single plus-symbol
instructs the register to overwrite any pre-existing declarations.
package MyApp::Person;
use Validation::Class;
set role => 'MyApp::User';
# append existing field and overwrite directives
field '++email_address' => {
required => 1
};
# redefine existing field
field '+login' => {
required => 1
};
filter
The filter keyword (or flt) registers custom filters to be used in your
field definitions. It is a means of extending the pre-existing filters
declared by the "filters directive" before instantiation.
package MyApp::Person;
use Validate::Class;
filter 'flatten' => sub {
$_[0] =~ s/[\t\r\n]+/ /g;
return $_[0];
};
field 'biography' => {
filters => ['trim', 'strip', 'flatten']
};
1;
The filter keyword takes two arguments, the name of the filter and a
coderef which will be used to filter the value the associated field. The
coderef is passed the value of the field and that value MUST be operated
on directly. The coderef should also return the transformed value.
load
The load keyword (or set), which can also be used as a class method,
provides options for extending the current class by declaring roles,
requirements, etc.
The process of applying roles, requirement, and other settings to the
current class mainly involves introspecting the namespace's methods and
merging relevant parts of the prototype configuration.
load-classes
The `classes` (or class) option uses Module::Find to load all child
classes (in-all-subdirectories) for convenient access through the
"class" in Validation::Class::Prototype method, and when introspecting a
larger application. This option accepts an arrayref or single argument.
package MyApp;
use Validation::Class;
load classes => ['MyApp::Domain1', 'MyApp::Domain2'];
package main;
my $app = MyApp->new;
my $person = $app->class('person'); # return a new MyApp::Person object
1;
load-requirements
package MyApp::User;
use Validate::Class;
load requirements => 'activate';
package MyApp::Person;
use Validation::Class;
load role => 'MyApp::User';
sub activate {}
1;
The `requirements` (or required) option is used to ensure that if/when
the class is used as a role the calling class has specific pre-existing
methods. This option accepts an arrayref or single argument.
package MyApp::User;
use Validate::Class;
load requirements => ['activate', 'deactivate'];
1;
load-roles
package MyApp::Person;
use Validation::Class;
load role => 'MyApp::User';
1;
The `roles` (or role) option is used to load and inherit functionality
from other validation classes. These classes should be used and
thought-of as roles although they can also be fully-functioning
validation classes. This option accepts an arrayref or single argument.
package MyApp::Person;
use Validation::Class;
load roles => ['MyApp::User', 'MyApp::Visitor'];
1;
message
The message keyword (or msg) registers a class-level error message
template that will be used in place of the error message defined in the
corresponding directive class if defined. Error messages can also be
overridden at the individual field-level as well. See the
Validation::Class::Directive::Messages for instructions on how to
override error messages at the field-level.
package MyApp::Person;
use Validation::Class;
field email_address => {
required => 1,
min_length => 3,
messages => {
# field-level error message override
min_length => '%s is not even close to being a valid email address'
}
};
# class-level error message overrides
message required => '%s is needed to proceed';
message min_length => '%s needs more characters';
1;
The message keyword takes two arguments, the name of the directive whose
error message you wish to override and a string which will be used to as
a template which is feed to sprintf to format the message.
method
The method keyword (or mth) is used to register an auto-validating
method. Similar to method signatures, an auto-validating method can
leverage pre-existing validation rules and profiles to ensure a method
has the required data necessary for execution.
package MyApp::Person;
use Validation::Class;
method 'register' => {
input => ['name', '+email', 'username', '+password', '+password2'],
output => ['+id'], # optional output validation, dies on failure
using => sub {
my ($self, @args) = @_;
# do something registrationy
$self->id(...); # set the ID field for output validation
return $self;
}
};
package main;
my $person = MyApp::Person->new(params => $params);
if ($person->register) {
# handle the successful registration
}
1;
The method keyword takes two arguments, the name of the method to be
created and a hashref of required key/value pairs. The hashref must have
an `input` key whose value is either an arrayref of fields to be
validated, or a scalar value which matches (a validation profile or
auto-validating method name). The hashref must also have a `using` key
whose value is a coderef which will be executed upon successfully
validating the input. The `using` key/coderef can be omitted when a
sub-routine of the same name prefixed with an underscore (or underscore
+ process + underscore) is present. Whether and what the method returns
is yours to decide. The method will return 0 if validation fails.
# alternate usage
method 'registration' => {
input => ['name', '+email', 'username', '+password', '+password2'],
output => ['+id'], # optional output validation, dies on failure
};
sub _process_registration {
my ($self, @args) = @_;
$self->id(...); # set the ID field for output validation
return $self;
}
Optionally the required hashref can have an `output` key whose value is
either an arrayref of fields to be validated, or a scalar value which
matches (a validation profile or auto-validating method name) which will
be used to perform data validation after the aforementioned coderef has
been executed.
Please note that output validation failure will cause the program to
die, the premise behind this decision is based on the assumption that
given successfully validated input a routine's output should be
predictable and if an error occurs it is most-likely a program error as
opposed to a user error.
See the ignore_failure and report_failure attributes on the prototype to
control how method input validation failures are handled.
mixin
The mixin keyword (or mxn) registers a validation rule template that can
be applied (or "mixed-in") to any field by specifying the mixin
directive. Mixin directives are processed first so existing field
directives will override any directives created by the mixin directive.
package MyApp::Person;
use Validation::Class;
mixin 'boilerplate' => {
required => 1,
min_length => 1,
max_length => 255
};
field 'username' => {
# min_length, max_length, .. required will be overridden
mixin => 'boilerplate',
required => 0
};
Since version 7.900015, all classes are automatically configured with
the following default mixins for the sake of convenience:
mixin ':flg' => {
required => 1,
min_length => 1,
filters => [qw/trim strip numeric/],
between => [0, 1]
};
mixin ':num' => {
required => 1,
min_length => 1,
filters => [qw/trim strip numeric/]
};
mixin ':str' => {
required => 1,
min_length => 1,
filters => [qw/trim strip/]
};
Please note that the aforementioned mixin names are prefixed with a
semi-colon but are treated as an exception to the rule. Prefixing mixin
names with a double plus-symbol instructs the register to merge your
declaration with any pre-existing declarations within the same scope
(e.g. mixins imported via loading roles), whereas prefixing mixin names
with a single plus-symbol instructs the register to overwrite any
pre-existing declarations.
package MyApp::Moderator;
use Validation::Class;
set role => 'MyApp::Person';
# overwrite and append existing mixin
mixin '++boilerplate' => {
min_symbols => 1
};
# redefine existing mixin
mixin '+username' => {
required => 1
};
The mixin keyword takes two arguments, the mixin name and a hashref of
key/values pairs known as directives.
profile
The profile keyword (or pro) registers a validation profile (coderef)
which as in the traditional use of the term is a sequence of validation
routines that validates data relevant to a specific action.
package MyApp::Person;
use Validation::Class;
profile 'check_email' => sub {
my ($self, @args) = @_;
if ($self->email_exists) {
my $email = $self->fields->get('email');
$email->errors->add('Email already exists');
return 0;
}
return 1;
};
package main;
my $user = MyApp::Person->new(params => $params);
unless ($user->validate_profile('check_email')) {
# handle failures
}
The profile keyword takes two arguments, a profile name and coderef
which will be used to execute a sequence of actions for validation
purposes.
METHODS
new
The new method instantiates a new class object, it performs a series of
actions (magic) required for the class to function properly, and for
that reason, this method should never be overridden. Use the build
keyword for hooking into the instantiation process.
In the event a foreign (pre-existing) `new` method is detected, an
`initialize_validator` method will be injected into the class containing
the code (magic) necessary to normalize your environment.
package MyApp::Person;
use Validation::Class;
# hook
build sub {
my ($self, @args) = @_; # on instantiation
};
sub new {
# rolled my own
my $self = bless {}, shift;
# execute magic
$self->initialize_validator;
}
prototype
The prototype method (or proto) returns an instance of the associated
class prototype. The class prototype is responsible for manipulating and
validating the data model (the class). It is not likely that you'll need
to access this method directly, see Validation::Class::Prototype.
package MyApp::Person;
use Validation::Class;
package main;
my $person = MyApp::Person->new;
my $prototype = $person->prototype;
PROXY METHODS
Validation::Class mostly provides sugar functions for modeling your data
validation requirements. Each class you create is associated with a
*prototype* class which provides the data validation engine and keeps
your class namespace free from pollution, please see
Validation::Class::Prototype for more information on specific methods
and attributes.
Validation::Class injects a few proxy methods into your class which are
basically aliases to the corresponding prototype class methods, however
it is possible to access the prototype directly using the
proto/prototype methods.
class
$self->class;
See "class" in Validation::Class::Prototype for full documentation.
clear_queue
$self->clear_queue;
See "clear_queue" in Validation::Class::Prototype for full
documentation.
error_count
$self->error_count;
See "error_count" in Validation::Class::Prototype for full
documentation.
error_fields
$self->error_fields;
See "error_fields" in Validation::Class::Prototype for full
documentation.
errors
$self->errors;
See "errors" in Validation::Class::Prototype for full documentation.
errors_to_string
$self->errors_to_string;
See "errors_to_string" in Validation::Class::Prototype for full
documentation.
get_errors
$self->get_errors;
See "get_errors" in Validation::Class::Prototype for full documentation.
get_fields
$self->get_fields;
See "get_fields" in Validation::Class::Prototype for full documentation.
get_hash
$self->get_hash;
See "get_hash" in Validation::Class::Prototype for full documentation.
get_params
$self->get_params;
See "get_params" in Validation::Class::Prototype for full documentation.
get_values
$self->get_values;
See "get_values" in Validation::Class::Prototype for full documentation.
fields
$self->fields;
See "fields" in Validation::Class::Prototype for full documentation.
filtering
$self->filtering;
See "filtering" in Validation::Class::Prototype for full documentation.
ignore_failure
$self->ignore_failure;
See "ignore_failure" in Validation::Class::Prototype for full
documentation.
ignore_unknown
$self->ignore_unknown;
See "ignore_unknown" in Validation::Class::Prototype for full
documentation.
is_valid
$self->is_valid;
See "is_valid" in Validation::Class::Prototype for full documentation.
param
$self->param;
See "param" in Validation::Class::Prototype for full documentation.
params
$self->params;
See "params" in Validation::Class::Prototype for full documentation.
plugin
$self->plugin;
See "plugin" in Validation::Class::Prototype for full documentation.
queue
$self->queue;
See "queue" in Validation::Class::Prototype for full documentation.
report_failure
$self->report_failure;
See "report_failure" in Validation::Class::Prototype for full
documentation.
report_unknown
$self->report_unknown;
See "report_unknown" in Validation::Class::Prototype for full
documentation.
reset_errors
$self->reset_errors;
See "reset_errors" in Validation::Class::Prototype for full
documentation.
reset_fields
$self->reset_fields;
See "reset_fields" in Validation::Class::Prototype for full
documentation.
reset_params
$self->reset_params;
See "reset_params" in Validation::Class::Prototype for full
documentation.
set_errors
$self->set_errors;
See "set_errors" in Validation::Class::Prototype for full documentation.
set_fields
$self->set_fields;
See "set_fields" in Validation::Class::Prototype for full documentation.
set_params
$self->set_params;
See "set_params" in Validation::Class::Prototype for full documentation.
set_method
$self->set_method;
See "set_method" in Validation::Class::Prototype for full documentation.
stash
$self->stash;
See "stash" in Validation::Class::Prototype for full documentation.
validate
$self->validate;
See "validate" in Validation::Class::Prototype for full documentation.
validate_method
$self->validate_method;
See "validate_method" in Validation::Class::Prototype for full
documentation.
validate_profile
$self->validate_profile;
See "validate_profile" in Validation::Class::Prototype for full
documentation.
EXTENSIBILITY
Validation::Class does NOT provide method modifiers but can be easily
extended with Class::Method::Modifiers.
before
before foo => sub { ... };
See "before method(s) => sub { ... }" in Class::Method::Modifiers for
full documentation.
around
around foo => sub { ... };
See "around method(s) => sub { ... }" in Class::Method::Modifiers for
full documentation.
after
after foo => sub { ... };
See "after method(s) => sub { ... }" in Class::Method::Modifiers for
full documentation.
SEE ALSO
If you have simple data validation needs, please review:
Validation::Class::Simple
Validation::Class validates strings, not structures. If you need a means
for validating object types you should be using a modern object system
like Mo, Moo, Mouse, or Moose. Alternatively you could use
Params::Validate.
In the event that you would like to look elsewhere for your data
validation needs, the following is a list of other validation
libraries/frameworks you might be interested in. If I've missed a really
cool new validation library please let me know.
HTML::FormHandler
This library seems to be the defacto standard for designing Moose
classes with HTML-centric data validation rules.
Data::Verifier
This library is a great approach towards adding robust validation
logic to your existing Moose-based codebase.
Validate::Tiny
This library is nice for simple use-cases, it has virtually no
dependencies and solid test coverage.
AUTHOR
Al Newkirk <anewkirk@ana.io>
COPYRIGHT AND LICENSE
This software is copyright (c) 2011 by Al Newkirk.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.