1Validation::Class(3) User Contributed Perl Documentation Validation::Class(3)
2
6 Validation::Class - Powerful Data Validation Framework
7
9 version 7.900057
10
12 use Validation::Class::Simple::Streamer;
13 my $params = {username => 'admin', password => 's3cret'};
15 my $input = Validation::Class::Simple::Streamer->new(params => $params);
16 # check username parameter
18 $input->check('username')->required->between('5-255');
19 $input->filters([qw/trim strip/]);
20 # check password parameter
22 $input->check('password')->required->between('5-255')->min_symbols(1);
23 $input->filters([qw/trim strip/]);
24 # run validate
26 $input->validate or die $input->errors_to_string;
27
29 Validation::Class is a scalable data validation library with interfaces
30 for applications of all sizes. The most common usage of
31 Validation::Class is to transform class namespaces into data validation
32 domains where consistency and reuse are primary concerns.
33 Validation::Class provides an extensible framework for defining
34 reusable data validation rules. It ships with a complete set of pre-
35 defined validations and filters referred to as "directives".
36 The core feature-set consist of self-validating methods, validation
38 profiles, reusable validation rules and templates, pre and post input
39 filtering, class inheritance, automatic array handling, and
40 extensibility (e.g. overriding default error messages, creating custom
41 validators, creating custom input filters and much more).
42 Validation::Class promotes DRY (don't repeat yourself) code. The main
43 benefit in using Validation::Class is that the architecture is designed
44 to increase the consistency of data input handling. The following is a
45 more traditional usage of Validation::Class, using the DSL to construct
46 a validator class:
47 package MyApp::Person;
49 use Validation::Class;
51 # data validation template
53 mixin basic => {
54 required => 1,
55 max_length => 255,
56 filters => [qw/trim strip/]
57 };
58 # data validation rules for the username parameter
60 field username => {
61 mixin => 'basic',
62 min_length => 5
63 };
64 # data validation rules for the password parameter
66 field password => {
67 mixin => 'basic',
68 min_length => 5,
69 min_symbols => 1
70 };
71 package main;
73 my $person = MyApp::Person->new(username => 'admin', password => 'secr3t');
75 # validate rules on the person object
77 unless ($person->validates) {
78 # handle the failures
79 warn $person->errors_to_string;
80 }
81 1;
83
85 If you are looking for a simple in-line data validation module built
86 using the same tenets and principles as Validation::Class, please
87 review Validation::Class::Simple or
88 Validation::Class::Simple::Streamer. If you are new to
89 Validation::Class, or would like more information on the underpinnings
90 of this library and how it views and approaches data validation, please
91 review Validation::Class::Whitepaper. Please review the "GUIDED-TOUR"
92 in Validation::Class::Cookbook for a detailed step-by-step look into
93 how Validation::Class works.
94
96 adopt
97 The adopt keyword (or adt) copies configuration and functionality from
98 other Validation::Class classes. The adopt keyword takes three
99 arguments, the name of the class to be introspected, and the
100 configuration type and name to be recreated. Basically, anything you
101 can configure using a Validation::Class keyword can be adopted into
102 other classes using this keyword with the exception of coderefs
103 registered using the build keyword. Please note! If you are adopting a
104 field declaration which has an associated mixin directive defined on
105 the target class, you must adopt the mixin explicitly if you wish it's
106 values to be interpolated.
107 package MyApp::Exployee;
109 use Validate::Class;
111 use MyApp::Person;
112 adopt MyApp::Person, mixin => 'basic';
114 adopt MyApp::Person, field => 'first_name';
115 adopt MyApp::Person, field => 'last_name';
116 adopt MyApp::Person, profile => 'has_fullname';
117 1;
119 attribute
121 The attribute keyword (or has) registers a class attribute, i.e. it
122 creates an accessor (getter and setter) on the class. Attribute
123 declaration is flexible and only requires an attribute name to be
124 configured. Additionally, the attribute keyword can takes two
125 arguments, the attribute's name and a scalar or coderef to be used as
126 it's default value.
127 package MyApp::Person;
129 use Validate::Class;
131 attribute 'first_name' => 'Peter';
133 attribute 'last_name' => 'Venkman';
134 attribute 'full_name' => sub {
135 join ', ', $_[0]->last_name, $_[0]->first_name
136 };
137 attribute 'email_address';
139 1;
141 build
143 The build keyword (or bld) registers a coderef to be run at
144 instantiation much in the same way the common BUILD routine is used in
145 modern OO frameworks.
146 package MyApp::Person;
148 use Validation::Class;
150 build sub {
152 my ($self, $args) = @_;
154 # run after instantiation in the order defined
156 };
158 1;
160 The build keyword takes one argument, a coderef which is passed the
162 instantiated class object.
163 directive
165 The directive keyword (or dir) registers custom validator directives to
166 be used in your field definitions. Please note that custom directives
167 can only be used with field definitions. This is a means of extending
168 the list of directives per instance. See the list of core directives,
169 Validation::Class::Directives, or review Validation::Class::Directive
170 for insight into creating your own CPAN installable directives.
171 package MyApp::Person;
173 use Validate::Class;
175 # define a custom class-level directive
177 directive 'blacklisted' => sub {
178 my ($self, $field, $param) = @_;
180 if (defined $field->{blacklisted} && defined $param) {
182 if ($field->{required} || $param) {
183 if (exists_in_blacklist($field->{blacklisted}, $param)) {
184 my $handle = $field->label || $field->name;
185 $field->errors->add("$handle has been blacklisted");
186 return 0;
187 }
188 }
189 }
190 return 1;
192 };
194 field 'email_address' => {
196 blacklisted => '/path/to/blacklist'
197 email => 1,
198 };
199 1;
201 The directive keyword takes two arguments, the name of the directive
203 and a coderef which will be used to validate the associated field. The
204 coderef is passed four ordered parameters; a directive object, the
205 class prototype object, the current field object, and the matching
206 parameter's value. The validator (coderef) is evaluated by its return
207 value as well as whether it altered any error containers.
208 document
210 The document keyword (or doc) registers a data matching profile which
211 can be used to validate heiarchal data. It will store a hashref with
212 pre-define path matching rules for the data structures you wish to
213 validate. The "path matching rules", which use a specialized object
214 notation, referred to as the document notation, can be thought of as a
215 kind-of simplified regular expression which is executed against the
216 flattened data structure. The following are a few general use-cases:
217 package MyApp::Person;
219 use Validation::Class;
221 field 'string' => {
223 mixin => [':str']
224 };
225 # given this JSON data structure
227 {
228 "id": "1234-A",
229 "name": {
230 "first_name" : "Bob",
231 "last_name" : "Smith",
232 },
233 "title": "CIO",
234 "friends" : [],
235 }
236 # select id to validate against the string rule
238 document 'foobar' =>
239 { 'id' => 'string' };
240 # select name -> first_name/last_name to validate against the string rule
242 document 'foobar' =>
243 {'name.first_name' => 'string', 'name.last_name' => 'string'};
244 # or
246 document 'foobar' =>
247 {'name.*_name' => 'string'};
248 # select each element in friends to validate against the string rule
250 document 'foobar' =>
251 { 'friends.@' => 'string' };
252 # or select an element of a hashref in each element in friends to validate
254 # against the string rule
255 document 'foobar' =>
256 { 'friends.@.name' => 'string' };
257 The document declaration's keys should follow the aforementioned
259 document notation schema and it's values should be strings which
260 correspond to the names of fields (or other document declarations) that
261 will be used to preform the data validation. It is possible to combine
262 document declarations to validate hierarchical data that contains data
263 structures matching one or more document patterns. The following is an
264 example of what that might look like.
265 package MyApp::Person;
267 use Validation::Class;
269 # data validation rule
271 field 'name' => {
272 mixin => [':str'],
273 pattern => qr/^[A-Za-z ]+$/,
274 max_length => 20,
275 };
276 # data validation map / document notation schema
278 document 'friend' => {
279 'name' => 'name'
280 };
281 # data validation map / document notation schema
283 document 'person' => {
284 'name' => 'name',
285 'friends.@' => 'friend'
286 };
287 package main;
289 my $data = {
291 "name" => "Anita Campbell-Green",
292 "friends" => [
293 { "name" => "Horace" },
294 { "name" => "Skinner" },
295 { "name" => "Alonzo" },
296 { "name" => "Frederick" },
297 ],
298 };
299 my $person = MyApp::Person->new;
301 unless ($person->validate_document(person => $data)) {
303 warn $person->errors_to_string if $person->error_count;
304 }
305 1;
307 Alternatively, the following is a more verbose data validation class
309 using traditional styling and configuration.
310 package MyApp::Person;
312 use Validation::Class;
314 field 'id' => {
316 mixin => [':str'],
317 filters => ['numeric'],
318 max_length => 2,
319 };
320 field 'name' => {
322 mixin => [':str'],
323 pattern => qr/^[A-Za-z ]+$/,
324 max_length => 20,
325 };
326 field 'rating' => {
328 mixin => [':str'],
329 pattern => qr/^\-?\d+$/,
330 };
331 field 'tag' => {
333 mixin => [':str'],
334 pattern => qr/^(?!evil)\w+/,
335 max_length => 20,
336 };
337 document 'person' => {
339 'id' => 'id',
340 'name' => 'name',
341 'company.name' => 'name',
342 'company.supervisor.name' => 'name',
343 'company.supervisor.rating.@.*' => 'rating',
344 'company.tags.@' => 'name'
345 };
346 package main;
348 my $data = {
350 "id" => "1234-ABC",
351 "name" => "Anita Campbell-Green",
352 "title" => "Designer",
353 "company" => {
354 "name" => "House of de Vil",
355 "supervisor" => {
356 "name" => "Cruella de Vil",
357 "rating" => [
358 { "support" => -9,
359 "guidance" => -9
360 }
361 ]
362 },
363 "tags" => [
364 "evil",
365 "cruelty",
366 "dogs"
367 ]
368 },
369 };
370 my $person = MyApp::Person->new;
372 unless ($person->validate_document(person => $data)) {
374 warn $person->errors_to_string if $person->error_count;
375 }
376 1;
378 Additionally, the following is yet another way to validate a document
380 by passing the document specification directly instead of by name.
381 package MyApp::Person;
383 use Validation::Class;
385 package main;
387 my $data = {
389 "id" => "1234-ABC",
390 "name" => "Anita Campbell-Green",
391 "title" => "Designer",
392 "company" => {
393 "name" => "House of de Vil",
394 "supervisor" => {
395 "name" => "Cruella de Vil",
396 "rating" => [
397 { "support" => -9,
398 "guidance" => -9
399 }
400 ]
401 },
402 "tags" => [
403 "evil",
404 "cruelty",
405 "dogs"
406 ]
407 },
408 };
409 my $spec = {
411 'id' => { max_length => 2 },
412 'name' => { mixin => ':str' },
413 'company.name' => { mixin => ':str' },
414 'company.supervisor.name' => { mixin => ':str' },
415 'company.supervisor.rating.@.*' => { pattern => qr/^(?!evil)\w+/ },
416 'company.tags.@' => { max_length => 20 },
417 };
418 my $person = MyApp::Person->new;
420 unless ($person->validate_document($spec => $data)) {
422 warn $person->errors_to_string if $person->error_count;
423 }
424 1;
426 ensure
428 The ensure keyword (or ens) is used to convert a pre-existing method
429 into an auto-validating method. The auto-validating method will be
430 registered and function as if it was created using the method keyword.
431 The original pre-existing method will be overridden with a modifed
432 version which performs the pre and/or post validation routines.
433 package MyApp::Person;
435 use Validation::Class;
437 sub register {
439 ...
440 }
441 ensure register => {
443 input => ['name', '+email', 'username', '+password', '+password2'],
444 output => ['+id'], # optional output validation, dies on failure
445 };
446 package main;
448 my $person = MyApp::Person->new(params => $params);
450 if ($person->register) {
452 # handle the successful registration
453 }
454 1;
456 The ensure keyword takes two arguments, the name of the method to be
458 overridden and a hashref of required key/value pairs. The hashref may
459 have an input key (e.g. input, input_document, input_profile, or
460 input_method). The `input` key (specifically) must have a value which
461 must be either an arrayref of fields to be validated, or a scalar value
462 which matches (a validation profile or auto-validating method name).
463 The hashref may also have an output key (e.g. output, output_document,
464 output_profile, or output_method). The `output` key (specifically)
465 must have a value which must be either an arrayref of fields to be
466 validated, or a scalar value which matches (a validation profile or
467 auto-validating method name). Whether and what the method returns is
468 yours to decide. The method will return undefined if validation fails.
469 The ensure keyword wraps and functions much in the same way as the
470 method keyword.
471 field
473 The field keyword (or fld) registers a data validation rule for reuse
474 and validation in code. The field name should correspond with the
475 parameter name expected to be passed to your validation class or
476 validated against.
477 package MyApp::Person;
479 use Validation::Class;
481 field 'username' => {
483 required => 1,
484 min_length => 1,
485 max_length => 255
486 };
487 The field keyword takes two arguments, the field name and a hashref of
489 key/values pairs known as directives. For more information on pre-
490 defined directives, please review the "list of core directives".
491 The field keyword also creates accessors which provide easy access to
493 the field's corresponding parameter value(s). Accessors will be created
494 using the field's name as a label having any special characters
495 replaced with an underscore.
496 # accessor will be created as send_reminders
498 field 'send-reminders' => {
499 length => 1
500 };
501 Please note that prefixing field names with a double plus-symbol
503 instructs the register to merge your declaration with any pre-existing
504 declarations within the same scope (e.g. fields imported via loading
505 roles), whereas prefixing field names with a single plus-symbol
506 instructs the register to overwrite any pre-existing declarations.
507 package MyApp::Person;
509 use Validation::Class;
511 set role => 'MyApp::User';
513 # append existing field and overwrite directives
515 field '++email_address' => {
516 required => 1
517 };
518 # redefine existing field
520 field '+login' => {
521 required => 1
522 };
523 1;
525 filter
527 The filter keyword (or flt) registers custom filters to be used in your
528 field definitions. It is a means of extending the pre-existing filters
529 declared by the "filters directive" before instantiation.
530 package MyApp::Person;
532 use Validate::Class;
534 filter 'flatten' => sub {
536 $_[0] =~ s/[\t\r\n]+/ /g;
537 return $_[0];
538 };
539 field 'biography' => {
541 filters => ['trim', 'strip', 'flatten']
542 };
543 1;
545 The filter keyword takes two arguments, the name of the filter and a
547 coderef which will be used to filter the value the associated field.
548 The coderef is passed the value of the field and that value MUST be
549 operated on directly. The coderef should also return the transformed
550 value.
551 load
553 The load keyword (or set), which can also be used as a class method,
554 provides options for extending the current class by declaring roles,
555 requirements, etc.
556 The process of applying roles, requirement, and other settings to the
558 current class mainly involves introspecting the namespace's methods and
559 merging relevant parts of the prototype configuration.
560 load-classes
562 The `classes` (or class) option uses Module::Find to load all child
563 classes (in-all-subdirectories) for convenient access through the
564 "class" in Validation::Class::Prototype method, and when introspecting
565 a larger application. This option accepts an arrayref or single
566 argument.
567 package MyApp;
569 use Validation::Class;
571 load classes => ['MyApp::Domain1', 'MyApp::Domain2'];
573 package main;
575 my $app = MyApp->new;
577 my $person = $app->class('person'); # return a new MyApp::Person object
579 1;
581 load-requirements
583 package MyApp::User;
584 use Validate::Class;
586 load requirements => 'activate';
588 package MyApp::Person;
590 use Validation::Class;
592 load role => 'MyApp::User';
594 sub activate {}
596 1;
598 The `requirements` (or required) option is used to ensure that if/when
600 the class is used as a role the calling class has specific pre-existing
601 methods. This option accepts an arrayref or single argument.
602 package MyApp::User;
604 use Validate::Class;
606 load requirements => ['activate', 'deactivate'];
608 1;
610 load-roles
612 package MyApp::Person;
613 use Validation::Class;
615 load role => 'MyApp::User';
617 1;
619 The `roles` (or role) option is used to load and inherit functionality
621 from other validation classes. These classes should be used and
622 thought-of as roles although they can also be fully-functioning
623 validation classes. This option accepts an arrayref or single argument.
624 package MyApp::Person;
626 use Validation::Class;
628 load roles => ['MyApp::User', 'MyApp::Visitor'];
630 1;
632 message
634 The message keyword (or msg) registers a class-level error message
635 template that will be used in place of the error message defined in the
636 corresponding directive class if defined. Error messages can also be
637 overridden at the individual field-level as well. See the
638 Validation::Class::Directive::Messages for instructions on how to
639 override error messages at the field-level.
640 package MyApp::Person;
642 use Validation::Class;
644 field email_address => {
646 required => 1,
647 min_length => 3,
648 messages => {
649 # field-level error message override
650 min_length => '%s is not even close to being a valid email address'
651 }
652 };
653 # class-level error message overrides
655 message required => '%s is needed to proceed';
656 message min_length => '%s needs more characters';
657 1;
659 The message keyword takes two arguments, the name of the directive
661 whose error message you wish to override and a string which will be
662 used to as a template which is feed to sprintf to format the message.
663 method
665 The method keyword (or mth) is used to register an auto-validating
666 method. Similar to method signatures, an auto-validating method can
667 leverage pre-existing validation rules and profiles to ensure a method
668 has the required pre/post-conditions and data necessary for execution.
669 package MyApp::Person;
671 use Validation::Class;
673 method 'register' => {
675 input => ['name', '+email', 'username', '+password', '+password2'],
677 output => ['+id'], # optional output validation, dies on failure
678 using => sub {
679 my ($self, @args) = @_;
681 # do something registrationy
683 $self->id(...); # set the ID field for output validation
684 return $self;
686 }
688 };
690 package main;
692 my $person = MyApp::Person->new(params => $params);
694 if ($person->register) {
696 # handle the successful registration
698 }
700 1;
702 The method keyword takes two arguments, the name of the method to be
704 created and a hashref of required key/value pairs. The hashref may have
705 a `using` key whose value is the coderef to be executed upon successful
706 validation. The `using` key is only optional when a pre-existing
707 subroutine has the same name or the method being declared prefixed with
708 a dash or dash-process-dash. The following are valid subroutine names
709 to be called by the method declaration in absence of a `using` key.
710 Please note, unlike the ensure keyword, any pre-existing subroutines
711 will not be wrapped-and-replaced and can be executed without validation
712 if called directly.
713 sub _name {
715 ...
716 }
717 sub _process_name {
719 ...
720 }
721 The hashref may have an input key (e.g. input, input_document,
723 input_profile, or input_method). The `input` key (specifically) must
724 have a value which must be either an arrayref of fields to be
725 validated, or a scalar value which matches (a validation profile or
726 auto-validating method name), which will be used to perform data
727 validation before the aforementioned coderef has been executed. Whether
728 and what the method returns is yours to decide. The method will return
729 undefined if validation fails.
730 # alternate usage
732 method 'registration' => {
734 input => ['name', '+email', 'username', '+password', '+password2'],
735 output => ['+id'], # optional output validation, dies on failure
736 };
737 sub _process_registration {
739 my ($self, @args) = @_;
740 $self->id(...); # set the ID field for output validation
741 return $self;
742 }
743 Optionally the hashref may also have an output key (e.g. output,
745 output_document, output_profile, or output_method). The `output` key
746 (specifically) must have a value which must be either an arrayref of
747 fields to be validated, or a scalar value which matches (a validation
748 profile or auto-validating method name), which will be used to perform
749 data validation after the aforementioned coderef has been executed.
750 Please note that output validation failure will cause the program to
752 die, the premise behind this decision is based on the assumption that
753 given successfully validated input a routine's output should be
754 predictable and if an error occurs it is most-likely a program error as
755 opposed to a user error.
756 See the ignore_failure and report_failure attributes on the prototype
758 to control how method validation failures are handled.
759 mixin
761 The mixin keyword (or mxn) registers a validation rule template that
762 can be applied (or "mixed-in") to any field by specifying the mixin
763 directive. Mixin directives are processed first so existing field
764 directives will override any directives created by the mixin directive.
765 package MyApp::Person;
767 use Validation::Class;
769 mixin 'boilerplate' => {
771 required => 1,
772 min_length => 1,
773 max_length => 255
774 };
775 field 'username' => {
777 # min_length, max_length, .. required will be overridden
778 mixin => 'boilerplate',
779 required => 0
780 };
781 Since version 7.900015, all classes are automatically configured with
783 the following default mixins for the sake of convenience:
784 mixin ':flg' => {
786 required => 1,
787 min_length => 1,
788 filters => [qw/trim strip numeric/],
789 between => [0, 1]
790 };
791 mixin ':num' => {
793 required => 1,
794 min_length => 1,
795 filters => [qw/trim strip numeric/]
796 };
797 mixin ':str' => {
799 required => 1,
800 min_length => 1,
801 filters => [qw/trim strip/]
802 };
803 Please note that the aforementioned mixin names are prefixed with a
805 semi-colon but are treated as an exception to the rule. Prefixing mixin
806 names with a double plus-symbol instructs the register to merge your
807 declaration with any pre-existing declarations within the same scope
808 (e.g. mixins imported via loading roles), whereas prefixing mixin names
809 with a single plus-symbol instructs the register to overwrite any pre-
810 existing declarations.
811 package MyApp::Moderator;
813 use Validation::Class;
815 set role => 'MyApp::Person';
817 # overwrite and append existing mixin
819 mixin '++boilerplate' => {
820 min_symbols => 1
821 };
822 # redefine existing mixin
824 mixin '+username' => {
825 required => 1
826 };
827 1;
829 The mixin keyword takes two arguments, the mixin name and a hashref of
831 key/values pairs known as directives.
832 profile
834 The profile keyword (or pro) registers a validation profile (coderef)
835 which as in the traditional use of the term is a sequence of validation
836 routines that validates data relevant to a specific action.
837 package MyApp::Person;
839 use Validation::Class;
841 profile 'check_email' => sub {
843 my ($self, @args) = @_;
845 if ($self->email_exists) {
847 my $email = $self->fields->get('email');
848 $email->errors->add('Email already exists');
849 return 0;
850 }
851 return 1;
853 };
855 package main;
857 my $user = MyApp::Person->new(params => $params);
859 unless ($user->validate_profile('check_email')) {
861 # handle failures
862 }
863 1;
865 The profile keyword takes two arguments, a profile name and coderef
867 which will be used to execute a sequence of actions for validation
868 purposes.
869
871 new
872 The new method instantiates a new class object, it performs a series of
873 actions (magic) required for the class to function properly, and for
874 that reason, this method should never be overridden. Use the build
875 keyword for hooking into the instantiation process.
876 In the event a foreign (pre-existing) `new` method is detected, an
878 `initialize_validator` method will be injected into the class
879 containing the code (magic) necessary to normalize your environment.
880 package MyApp::Person;
882 use Validation::Class;
884 # hook
886 build sub {
887 my ($self, @args) = @_; # on instantiation
889 };
891 sub new {
893 # rolled my own
895 my $self = bless {}, shift;
896 # execute magic
898 $self->initialize_validator;
899 }
901 1;
903 prototype
905 The prototype method (or proto) returns an instance of the associated
906 class prototype. The class prototype is responsible for manipulating
907 and validating the data model (the class). It is not likely that you'll
908 need to access this method directly, see Validation::Class::Prototype.
909 package MyApp::Person;
911 use Validation::Class;
913 package main;
915 my $person = MyApp::Person->new;
917 my $prototype = $person->prototype;
919 1;
921
923 Validation::Class mostly provides sugar functions for modeling your
924 data validation requirements. Each class you create is associated with
925 a prototype class which provides the data validation engine and keeps
926 your class namespace free from pollution, please see
927 Validation::Class::Prototype for more information on specific methods
928 and attributes. Validation::Class injects a few proxy methods into your
929 class which are basically aliases to the corresponding prototype class
930 methods, however it is possible to access the prototype directly using
931 the proto/prototype methods.
932 class
934 $self->class;
935 See "class" in Validation::Class::Prototype for full documentation.
937 clear_queue
939 $self->clear_queue;
940 See "clear_queue" in Validation::Class::Prototype for full
942 documentation.
943 error_count
945 $self->error_count;
946 See "error_count" in Validation::Class::Prototype for full
948 documentation.
949 error_fields
951 $self->error_fields;
952 See "error_fields" in Validation::Class::Prototype for full
954 documentation.
955 errors
957 $self->errors;
958 See "errors" in Validation::Class::Prototype for full documentation.
960 errors_to_string
962 $self->errors_to_string;
963 See "errors_to_string" in Validation::Class::Prototype for full
965 documentation.
966 get_errors
968 $self->get_errors;
969 See "get_errors" in Validation::Class::Prototype for full
971 documentation.
972 get_fields
974 $self->get_fields;
975 See "get_fields" in Validation::Class::Prototype for full
977 documentation.
978 get_hash
980 $self->get_hash;
981 See "get_hash" in Validation::Class::Prototype for full documentation.
983 get_params
985 $self->get_params;
986 See "get_params" in Validation::Class::Prototype for full
988 documentation.
989 get_values
991 $self->get_values;
992 See "get_values" in Validation::Class::Prototype for full
994 documentation.
995 fields
997 $self->fields;
998 See "fields" in Validation::Class::Prototype for full documentation.
1000 filtering
1002 $self->filtering;
1003 See "filtering" in Validation::Class::Prototype for full documentation.
1005 ignore_failure
1007 $self->ignore_failure;
1008 See "ignore_failure" in Validation::Class::Prototype for full
1010 documentation.
1011 ignore_intervention
1013 $self->ignore_intervention;
1014 See "ignore_intervention" in Validation::Class::Prototype for full
1016 documentation.
1017 ignore_unknown
1019 $self->ignore_unknown;
1020 See "ignore_unknown" in Validation::Class::Prototype for full
1022 documentation.
1023 is_valid
1025 $self->is_valid;
1026 See "is_valid" in Validation::Class::Prototype for full documentation.
1028 param
1030 $self->param;
1031 See "param" in Validation::Class::Prototype for full documentation.
1033 params
1035 $self->params;
1036 See "params" in Validation::Class::Prototype for full documentation.
1038 plugin
1040 $self->plugin;
1041 See "plugin" in Validation::Class::Prototype for full documentation.
1043 queue
1045 $self->queue;
1046 See "queue" in Validation::Class::Prototype for full documentation.
1048 report_failure
1050 $self->report_failure;
1051 See "report_failure" in Validation::Class::Prototype for full
1053 documentation.
1054 report_unknown
1056 $self->report_unknown;
1057 See "report_unknown" in Validation::Class::Prototype for full
1059 documentation.
1060 reset_errors
1062 $self->reset_errors;
1063 See "reset_errors" in Validation::Class::Prototype for full
1065 documentation.
1066 reset_fields
1068 $self->reset_fields;
1069 See "reset_fields" in Validation::Class::Prototype for full
1071 documentation.
1072 reset_params
1074 $self->reset_params;
1075 See "reset_params" in Validation::Class::Prototype for full
1077 documentation.
1078 set_errors
1080 $self->set_errors;
1081 See "set_errors" in Validation::Class::Prototype for full
1083 documentation.
1084 set_fields
1086 $self->set_fields;
1087 See "set_fields" in Validation::Class::Prototype for full
1089 documentation.
1090 set_params
1092 $self->set_params;
1093 See "set_params" in Validation::Class::Prototype for full
1095 documentation.
1096 set_method
1098 $self->set_method;
1099 See "set_method" in Validation::Class::Prototype for full
1101 documentation.
1102 stash
1104 $self->stash;
1105 See "stash" in Validation::Class::Prototype for full documentation.
1107 validate
1109 $self->validate;
1110 See "validate" in Validation::Class::Prototype for full documentation.
1112 validate_document
1114 $self->validate_document;
1115 See "validate_document" in Validation::Class::Prototype for full
1117 documentation.
1118 validate_method
1120 $self->validate_method;
1121 See "validate_method" in Validation::Class::Prototype for full
1123 documentation.
1124 validate_profile
1126 $self->validate_profile;
1127 See "validate_profile" in Validation::Class::Prototype for full
1129 documentation.
1130
1132 Validation::Class is stable, its feature-set is complete, and is
1133 currently in maintenance-only mode, i.e. Validation::Class will only be
1134 updated with minor enhancements and bug fixes. However, the lessons
1135 learned will be incorporated into a compelete rewrite uploaded under
1136 the namespace Validation::Interface. The Validation::Interface fork is
1137 designed to have a much simpler API with less options and better
1138 execution, focused on validating hierarchical data as its primarily
1139 objective.
1140
1142 Validation::Class does NOT provide method modifiers but can be easily
1143 extended with Class::Method::Modifiers.
1144 before
1146 before foo => sub { ... };
1147 See "before method(s) => sub { ... }" in Class::Method::Modifiers for
1149 full documentation.
1150 around
1152 around foo => sub { ... };
1153 See "around method(s) => sub { ... }" in Class::Method::Modifiers for
1155 full documentation.
1156 after
1158 after foo => sub { ... };
1159 See "after method(s) => sub { ... }" in Class::Method::Modifiers for
1161 full documentation.
1162
1164 Validation::Class does not validate blessed objects. If you need a
1165 means for validating object types you should use a modern object system
1166 like Moo, Mouse, or Moose. Alternatively, you could use decoupled
1167 object validators like Type::Tiny, Params::Validate or Specio.
1168
1170 Al Newkirk <anewkirk@ana.io>
1171
1173 This software is copyright (c) 2011 by Al Newkirk.
1174 This is free software; you can redistribute it and/or modify it under
1176 the same terms as the Perl 5 programming language system itself.
1177
1179 Hey! The above document had some coding errors, which are explained
1180 below:
1181 Around line 1796:
1183 =back without =over
1184perl v5.30.1 2020-01-30 Validation::Class(3)