Provided by: libvalidation-class-perl_7.900057-2_all bug

NAME

       Validation::Class - Powerful Data Validation Framework

VERSION

       version 7.900057

SYNOPSIS

           use Validation::Class::Simple::Streamer;

           my  $params = {username => 'admin', password => 's3cret'};
           my  $input  = Validation::Class::Simple::Streamer->new(params => $params);

           # 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 validate
           $input->validate or die $input->errors_to_string;

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, using the DSL to construct a validator
       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 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::Cookbook for a detailed step-by-step look into how Validation::Class
       works.

KEYWORDS

   adopt
       The adopt keyword (or adt) copies configuration and functionality from other
       Validation::Class classes. The adopt keyword takes three arguments, the name of the class
       to be introspected, and the configuration type and name to be recreated. Basically,
       anything you can configure using a Validation::Class keyword can be adopted into other
       classes using this keyword with the exception of coderefs registered using the build
       keyword. Please note! If you are adopting a field declaration which has an associated
       mixin directive defined on the target class, you must adopt the mixin explicitly if you
       wish it's values to be interpolated.

           package MyApp::Exployee;

           use Validate::Class;
           use MyApp::Person;

           adopt MyApp::Person, mixin   => 'basic';
           adopt MyApp::Person, field   => 'first_name';
           adopt MyApp::Person, field   => 'last_name';
           adopt MyApp::Person, profile => 'has_fullname';

           1;

   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;

           attribute 'first_name' => 'Peter';
           attribute 'last_name'  => 'Venkman';
           attribute 'full_name'  => sub {
               join ', ', $_[0]->last_name, $_[0]->first_name
           };

           attribute '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

           };

           1;

       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. Please note that custom directives can only be used with 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.

   document
       The document keyword (or doc) registers a data matching profile which can be used to
       validate heiarchal data. It will store a hashref with pre-define path matching rules for
       the data structures you wish to validate. The "path matching rules", which use a
       specialized object notation, referred to as the document notation, can be thought of as a
       kind-of simplified regular expression which is executed against the flattened data
       structure. The following are a few general use-cases:

           package MyApp::Person;

           use Validation::Class;

           field  'string' => {
               mixin => [':str']
           };

           # given this JSON data structure
           {
               "id": "1234-A",
               "name": {
                   "first_name" : "Bob",
                   "last_name"  : "Smith",
                },
               "title": "CIO",
               "friends" : [],
           }

           # select id to validate against the string rule
           document 'foobar'  =>
               { 'id' => 'string' };

           # select name -> first_name/last_name to validate against the string rule
           document 'foobar'  =>
               {'name.first_name' => 'string', 'name.last_name' => 'string'};

           # or
           document 'foobar'  =>
               {'name.*_name' => 'string'};

           # select each element in friends to validate against the string rule
           document 'foobar'  =>
               { 'friends.@'  => 'string' };

           # or select an element of a hashref in each element in friends to validate
           # against the string rule
           document 'foobar'  =>
               { 'friends.@.name' => 'string' };

       The document declaration's keys should follow the aforementioned document notation schema
       and it's values should be strings which correspond to the names of fields (or other
       document declarations) that will be used to preform the data validation. It is possible to
       combine document declarations to validate hierarchical data that contains data structures
       matching one or more document patterns. The following is an example of what that might
       look like.

           package MyApp::Person;

           use Validation::Class;

           # data validation rule
           field  'name' => {
               mixin      => [':str'],
               pattern    => qr/^[A-Za-z ]+$/,
               max_length => 20,
           };

           # data validation map / document notation schema
           document 'friend' => {
               'name' => 'name'
           };

           # data validation map / document notation schema
           document 'person' => {
               'name' => 'name',
               'friends.@' => 'friend'
           };

           package main;

           my $data = {
               "name"   => "Anita Campbell-Green",
               "friends" => [
                   { "name" => "Horace" },
                   { "name" => "Skinner" },
                   { "name" => "Alonzo" },
                   { "name" => "Frederick" },
               ],
           };

           my $person = MyApp::Person->new;

           unless ($person->validate_document(person => $data)) {
               warn $person->errors_to_string if $person->error_count;
           }

           1;

       Alternatively, the following is a more verbose data validation class using traditional
       styling and configuration.

           package MyApp::Person;

           use Validation::Class;

           field  'id' => {
               mixin      => [':str'],
               filters    => ['numeric'],
               max_length => 2,
           };

           field  'name' => {
               mixin      => [':str'],
               pattern    => qr/^[A-Za-z ]+$/,
               max_length => 20,
           };

           field  'rating' => {
               mixin      => [':str'],
               pattern    => qr/^\-?\d+$/,
           };

           field  'tag' => {
               mixin      => [':str'],
               pattern    => qr/^(?!evil)\w+/,
               max_length => 20,
           };

           document 'person' => {
               'id'                             => 'id',
               'name'                           => 'name',
               'company.name'                   => 'name',
               'company.supervisor.name'        => 'name',
               'company.supervisor.rating.@.*'  => 'rating',
               'company.tags.@'                 => 'name'
           };

           package main;

           my $data = {
               "id"      => "1234-ABC",
               "name"    => "Anita Campbell-Green",
               "title"   => "Designer",
               "company" => {
                   "name"       => "House of de Vil",
                   "supervisor" => {
                       "name"   => "Cruella de Vil",
                       "rating" => [
                           {   "support"  => -9,
                               "guidance" => -9
                           }
                       ]
                   },
                   "tags" => [
                       "evil",
                       "cruelty",
                       "dogs"
                   ]
               },
           };

           my $person = MyApp::Person->new;

           unless ($person->validate_document(person => $data)) {
               warn $person->errors_to_string if $person->error_count;
           }

           1;

       Additionally, the following is yet another way to validate a document by passing the
       document specification directly instead of by name.

           package MyApp::Person;

           use Validation::Class;

           package main;

           my $data = {
               "id"      => "1234-ABC",
               "name"    => "Anita Campbell-Green",
               "title"   => "Designer",
               "company" => {
                   "name"       => "House of de Vil",
                   "supervisor" => {
                       "name"   => "Cruella de Vil",
                       "rating" => [
                           {   "support"  => -9,
                               "guidance" => -9
                           }
                       ]
                   },
                   "tags" => [
                       "evil",
                       "cruelty",
                       "dogs"
                   ]
               },
           };

           my $spec = {
               'id'                            => { max_length => 2 },
               'name'                          => { mixin      => ':str' },
               'company.name'                  => { mixin      => ':str' },
               'company.supervisor.name'       => { mixin      => ':str' },
               'company.supervisor.rating.@.*' => { pattern    => qr/^(?!evil)\w+/ },
               'company.tags.@'                => { max_length => 20 },
           };

           my $person = MyApp::Person->new;

           unless ($person->validate_document($spec => $data)) {
               warn $person->errors_to_string if $person->error_count;
           }

           1;

   ensure
       The ensure keyword (or ens) is used to convert a pre-existing method into an auto-
       validating method. The auto-validating method will be registered and function as if it was
       created using the method keyword.  The original pre-existing method will be overridden
       with a modified version which performs the pre and/or post validation routines.

           package MyApp::Person;

           use Validation::Class;

           sub register {
               ...
           }

           ensure register => {
               input  => ['name', '+email', 'username', '+password', '+password2'],
               output => ['+id'], # optional output validation, dies on failure
           };

           package main;

           my $person = MyApp::Person->new(params => $params);

           if ($person->register) {
               # handle the successful registration
           }

           1;

       The ensure keyword takes two arguments, the name of the method to be overridden and a
       hashref of required key/value pairs. The hashref may have an input key (e.g. input,
       input_document, input_profile, or input_method).  The `input` key (specifically) must have
       a value which must be either an arrayref of fields to be validated, or a scalar value
       which matches (a validation profile or auto-validating method name). The hashref may also
       have an output key (e.g. output, output_document, output_profile, or output_method).  The
       `output` key (specifically) must have a value which must be either an arrayref of fields
       to be validated, or a scalar value which matches (a validation profile or auto-validating
       method name). Whether and what the method returns is yours to decide. The method will
       return undefined if validation fails. The ensure keyword wraps and functions much in the
       same way as the method keyword.

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

           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 pre/post-conditions and 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 may have a `using` key whose value is the coderef
       to be executed upon successful validation. The `using` key is only optional when a pre-
       existing subroutine has the same name or the method being declared prefixed with a dash or
       dash-process-dash. The following are valid subroutine names to be called by the method
       declaration in absence of a `using` key. Please note, unlike the ensure keyword, any pre-
       existing subroutines will not be wrapped-and-replaced and can be executed without
       validation if called directly.

           sub _name {
               ...
           }

           sub _process_name {
               ...
           }

       The hashref may have an input key (e.g. input, input_document, input_profile, or
       input_method). The `input` key (specifically) must have a value which must be 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 before the
       aforementioned coderef has been executed. Whether and what the method returns is yours to
       decide. The method will return undefined 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 hashref may also have an output key (e.g. output, output_document,
       output_profile, or output_method). The `output` key (specifically) must have a value which
       must be 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 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
           };

           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
           }

           1;

       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;

           }

           1;

   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;

           1;

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_intervention
           $self->ignore_intervention;

       See "ignore_intervention" 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_document
           $self->validate_document;

       See "validate_document" 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.

UPGRADE

       Validation::Class is stable, its feature-set is complete, and is currently in maintenance-
       only mode, i.e. Validation::Class will only be updated with minor enhancements and bug
       fixes. However, the lessons learned will be incorporated into a compelete rewrite uploaded
       under the namespace Validation::Interface.  The Validation::Interface fork is designed to
       have a much simpler API with less options and better execution, focused on validating
       hierarchical data as its primarily objective.

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

       Validation::Class does not validate blessed objects. If you need a means for validating
       object types you should use a modern object system like Moo, Mouse, or Moose.
       Alternatively, you could use decoupled object validators like Type::Tiny, Params::Validate
       or Specio.

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.