1 package WebPAC::Validate;
8 use base 'WebPAC::Common';
10 use List::Util qw/first/;
11 use Data::Dump qw/dump/;
12 use WebPAC::Normalize qw/_pack_subfields_hash/;
13 use Storable qw/dclone/;
17 WebPAC::Validate - provide simple validation for records
25 our $VERSION = '0.11';
29 This module provide a simple way to validate your file against a simple
30 configuration file in following format:
32 # field 10 doesn't have any subfields
36 # field 200 have valid subfields a-g
37 # and field e is repeatable
39 # field 205 can have only subfield a
42 # while 210 can have a c or d
44 # field which is ignored in validation
51 Create new validation object
53 my $validate = new WebPAC::Validate(
54 path => 'conf/validate/file',
55 delimiters => [ ' : ', ' / ', ' ; ', ' , ' ],
58 Optional parametar C<delimiters> will turn on validating of delimiters. Be
59 careful here, those delimiters are just stuck into regex, so they can
60 contain L<perlre> regexpes.
69 my $log = $self->_get_logger();
71 foreach my $p (qw/path/) {
72 $log->logconfess("need $p") unless ($self->{$p});
75 my $v_file = read_file( $self->{path} ) ||
76 $log->logdie("can't open validate path $self->{path}: $!");
81 foreach my $l (split(/[\n\r]+/, $v_file)) {
84 # skip comments and whitespaces
85 next if ($l =~ /^#/ || $l =~ /^\s*$/);
90 my @d = split(/\s+/, $l);
95 $self->{must_exist}->{$fld}++;
96 } elsif ($fld =~ s/-$//) {
97 $self->{dont_validate}->{$fld}++;
100 $log->logdie("need field name in line $curr_line: $l") unless (defined($fld));
105 if ( $sf =~ s/!(\*)?$/$1/ ) {
106 $self->{must_exist_sf}->{ $fld }->{ $sf }++;
116 $log->debug("current validation rules: ", dump($v));
120 $log->info("validation uses rules from $self->{path}");
122 if ( $self->{delimiters} ) {
123 $self->{delimiters_regex} = '(\^[a-z0-9]|' . join('|', @{ $self->{delimiters} }) . ')';
124 $log->info("validation check delimiters with regex $self->{delimiters_regex}");
127 $self ? return $self : return undef;
132 Validate record and return errors
134 my @errors = $validate->validate_rec( $rec, $rec_dump );
141 my $log = $self->_get_logger();
143 my $rec = shift || $log->logdie("validate_rec need record");
144 my $rec_dump = shift;
146 $log->logdie("rec isn't HASH") unless (ref($rec) eq 'HASH');
147 $log->logdie("can't find validation rules") unless (my $r = $self->{rules});
151 $log->debug("rec = ", sub { dump($rec) }, "keys = ", keys %{ $rec });
155 foreach my $f (keys %{ $rec }) {
157 next if (!defined($f) || $f eq '' || $f eq '000');
159 # first check delimiters
160 if ( my $regex = $self->{delimiters_regex} ) {
162 foreach my $v (@{ $rec->{$f} }) {
163 my $l = _pack_subfields_hash( $v, 1 );
165 $l =~ s/$regex/$template.=$1/eg;
166 # warn "## template: $template\n";
167 $self->{_delimiters_templates}->{$f}->{$template}++ if ( $template );
172 next if (defined( $self->{dont_validate}->{$f} ));
177 if ( ! defined($r->{$f}) ) {
178 $errors->{ $f }->{unexpected} = "this field is not expected";
183 if (ref($rec->{$f}) ne 'ARRAY') {
184 $errors->{ $f }->{not_repeatable} = "probably bug in parsing input data";
188 foreach my $v (@{ $rec->{$f} }) {
189 # can we have subfields?
190 if (ref($r->{$f}) eq 'ARRAY') {
191 # are values hashes? (has subfields)
193 # $errors->{$f}->{empty} = undef;
194 # $errors->{dump} = $rec_dump if ($rec_dump);
195 } elsif (ref($v) ne 'HASH') {
196 $errors->{$f}->{missing_subfield} = join(",", @{ $r->{$f} }) . " required";
200 my $h = dclone( $v );
204 delete($v->{subfields}) if (defined($v->{subfields}));
208 foreach my $sf (keys %{ $v }) {
210 $subfields->{ $sf }++;
212 # is non-repeatable but with multiple values?
213 if ( ! first { $_ eq $sf.'*' } @{$r->{$f}} ) {
214 if ( ref($v->{$sf}) eq 'ARRAY' ) {
215 $sf_repeatable->{$sf}++;
217 if (! first { $_ eq $sf } @{ $r->{$f} }) {
218 $errors->{ $f }->{subfield}->{extra}->{$sf}++;
223 if (my @r_sf = sort keys( %$sf_repeatable )) {
225 foreach my $sf (@r_sf) {
226 $errors->{$f}->{subfield}->{extra_repeatable}->{$sf}++;
227 $errors->{$f}->{dump} = _pack_subfields_hash( $h, 1 );
232 if ( defined( $self->{must_exist_sf}->{$f} ) ) {
233 foreach my $sf (sort keys %{ $self->{must_exist_sf}->{$f} }) {
234 #warn "====> $f $sf must exist\n";
235 $errors->{$f}->{subfield}->{missing}->{$sf}++
236 unless defined( $subfields->{$sf} );
241 } elsif (ref($v) eq 'HASH') {
242 $errors->{$f}->{unexpected_subfields}++;
243 $errors->{$f}->{dump} = _pack_subfields_hash( $v, 1 );
248 $log->debug("_delimiters_templates = ", dump( $self->{_delimiters_templates} ) );
250 foreach my $must (sort keys %{ $self->{must_exist} }) {
251 next if ($fields->{$must});
252 $errors->{$must}->{missing}++;
253 $errors->{dump} = $rec_dump if ($rec_dump);
257 $log->debug("errors: ", $self->report_error( $errors ) );
259 my $mfn = $rec->{'000'}->[0] || $log->logconfess("record ", dump( $rec ), " doesn't have MFN");
260 $self->{errors}->{$mfn} = $errors;
263 #$log->logcluck("return from this function is ARRAY") unless wantarray;
270 Clean all accumulated errors for this input
272 $validate->reset_errors;
278 delete ($self->{errors});
283 Return hash with all errors
285 print dump( $validate->all_errors );
291 return $self->{errors};
296 Produce nice humanly readable report of single error
298 print $validate->report_error( $error_hash );
305 my $h = shift || die "no hash?";
308 my ($self, $tree, $accumulated) = @_;
310 my $log = $self->_get_logger();
313 ( $tree ? "tree: $tree " : '' ),
314 ( $accumulated ? "accumulated: $accumulated " : '' ),
319 if (ref($tree) ne 'HASH') {
320 return ("$accumulated\t($tree)", undef);
325 foreach my $k (sort keys %{ $tree }) {
328 $dump = $tree->{dump};
329 # warn "## dump: ",dump($dump),"\n";
333 $log->debug("current: $k");
335 my ($new_results, $new_dump) = $self->_unroll($tree->{$k},
336 $accumulated ? "$accumulated\t$k" : $k
340 ( $new_results ? "new_results: " . dump($new_results) ." " : '' ),
343 push @$results, $new_results if ($new_results);
344 $dump = $new_dump if ($new_dump);
349 ( $results ? "results: " . dump($results) ." " : '' ),
352 if ($#$results == 0) {
353 return ($results->[0], $dump);
355 return ($results, $dump);
369 for my $f (sort keys %{ $h }) {
372 my ($r, $d) = $self->_unroll( $h->{$f} );
374 if (ref($r) eq 'ARRAY') {
375 $e .= join(", ", map { _reformat( $_ ) } @$r);
377 $e .= _reformat( $r );
379 $e .= "\n\t$d" if ($d);
389 Produce nice humanly readable report of errors
391 print $validate->report;
397 my $e = $self->{errors} || return;
400 foreach my $mfn (sort { $a <=> $b } keys %$e) {
401 $out .= "MFN $mfn\n" . $self->report_error( $e->{$mfn} ) . "\n";
408 =head2 delimiters_templates
413 sub delimiters_templates {
416 my $t = $self->{_delimiters_templates};
418 my $log = $self->_get_logger;
421 $log->warn("called without delimiters");
427 foreach my $f (sort { $a <=> $b } keys %$t) {
429 foreach my $sft (sort { $a cmp $b } keys %{ $t->{$f} }) {
430 $out .= "\t" . $t->{$f}->{$sft} . "\t$sft\n";
439 Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>
441 =head1 COPYRIGHT & LICENSE
443 Copyright 2006 Dobrica Pavlinusic, All Rights Reserved.
445 This program is free software; you can redistribute it and/or modify it
446 under the same terms as Perl itself.
450 1; # End of WebPAC::Validate