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.12';
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 => [ ' : ', ' / ', ' ; ', ' , ' ],
56 delimiters_path => 'conf/validate/delimiters/file',
59 Optional parametar C<delimiters> will turn on validating of delimiters. Be
60 careful here, those delimiters are just stuck into regex, so they can
61 contain L<perlre> regexpes.
63 C<path> and C<delimiters_path> can be specified by L<read_validate_file> and
64 L<read_validate_delimiters> calls.
73 my $log = $self->_get_logger();
75 $self->read_validate_file( $self->{path} ) if ( $self->{path} );
77 if ( $self->{delimiters} ) {
78 $self->{delimiters_regex} = '(\^[a-z0-9]|' . join('|', @{ $self->{delimiters} }) . ')';
79 $log->info("validation check delimiters with regex $self->{delimiters_regex}");
82 $self->read_validate_delimiters_file( $self->{delimiters_path} ) if ( $self->{delimiters_path} );
88 =head2 read_validate_file
90 Specify validate rules file
92 $validate->read_validate_file( 'conf/validate/file' );
94 Returns number of lines in file
98 sub read_validate_file {
101 my $path = shift || die "no path?";
103 my $log = $self->_get_logger();
105 my $v_file = read_file( $path ) ||
106 $log->logdie("can't open validate path $path: $!");
109 delete( $self->{must_exist} );
110 delete( $self->{must_exist_sf} );
111 delete( $self->{dont_validate} );
114 foreach my $l (split(/[\n\r]+/, $v_file)) {
117 # skip comments and whitespaces
118 next if ($l =~ /^#/ || $l =~ /^\s*$/);
123 my @d = split(/\s+/, $l);
127 if ($fld =~ s/!$//) {
128 $self->{must_exist}->{$fld}++;
129 } elsif ($fld =~ s/-$//) {
130 $self->{dont_validate}->{$fld}++;
133 $log->logdie("need field name in line $curr_line: $l") unless (defined($fld));
138 if ( $sf =~ s/!// ) {
139 $self->{must_exist_sf}->{ $fld }->{ $sf }++;
149 $log->debug("current validation rules: ", dump($v));
153 $log->info("validation uses rules from $path");
158 =head2 read_validate_delimiters_file
160 $validate->read_validate_delimiters_file( 'conf/validate/delimiters/file' );
164 sub read_validate_delimiters_file {
167 my $path = shift || die "no path?";
169 my $log = $self->_get_logger();
171 delete( $self->{_validate_delimiters_templates} );
172 delete( $self->{_delimiters_templates} );
175 $log->info("using delimiter validation rules from $path");
176 open(my $d, $path) || $log->fatal("can't open $path: $!");
179 if (/^\s*(#*)\s*(\d+)\t+(\d+)\t+(.*)$/) {
180 my ($comment,$field,$count,$template) = ($1,$2,$3,$4);
181 $self->{_validate_delimiters_templates}->{$field}->{$template} = $count unless ($comment);
183 warn "## ignored $d\n";
187 #warn "_validate_delimiters_templates = ",dump( $self->{_validate_delimiters_templates} );
189 $log->warn("delimiters path $path doesn't exist, it will be created after this run");
191 $self->{delimiters_path} = $path;
196 Validate record and return errors
198 my @errors = $validate->validate_rec( $rec, $rec_dump );
205 my $log = $self->_get_logger();
207 my $rec = shift || $log->logdie("validate_rec need record");
208 my $rec_dump = shift;
210 $log->logdie("rec isn't HASH") unless (ref($rec) eq 'HASH');
211 # $log->logdie("can't find validation rules") unless (my $r = $self->{rules});
212 my $r = $self->{rules};
216 $log->debug("rec = ", sub { dump($rec) }, "keys = ", keys %{ $rec });
220 foreach my $f (keys %{ $rec }) {
222 next if (!defined($f) || $f eq '' || $f eq '000');
224 # first check delimiters
225 if ( my $regex = $self->{delimiters_regex} ) {
227 foreach my $v (@{ $rec->{$f} }) {
228 my $l = _pack_subfields_hash( $v, 1 );
229 my $subfield_dump = $l;
231 $l =~ s/$regex/$template.=$1/eg;
232 #warn "## template: $template\n";
235 $self->{_delimiters_templates}->{$f}->{$template}++;
237 if ( my $v = $self->{_validate_delimiters_templates} ) {
238 if ( ! defined( $v->{$f}->{$template} ) ) {
239 $errors->{$f}->{potentially_invalid_combination} = $template;
240 $errors->{$f}->{dump} = $subfield_dump;
242 # warn "## $f $template ok\n";
249 next unless ( $r ); # skip validation of no rules are specified
251 next if (defined( $self->{dont_validate}->{$f} ));
256 if ( ! defined($r->{$f}) ) {
257 $errors->{ $f }->{unexpected} = "this field is not expected";
262 if (ref($rec->{$f}) ne 'ARRAY') {
263 $errors->{ $f }->{not_repeatable} = "probably bug in parsing input data";
267 foreach my $v (@{ $rec->{$f} }) {
268 # can we have subfields?
269 if (ref($r->{$f}) eq 'ARRAY') {
270 # are values hashes? (has subfields)
272 # $errors->{$f}->{empty} = undef;
273 # $errors->{dump} = $rec_dump if ($rec_dump);
274 } elsif (ref($v) ne 'HASH') {
275 $errors->{$f}->{missing_subfield} = join(",", @{ $r->{$f} }) . " required";
276 $errors->{$f}->{dump} = $v;
280 my $h = dclone( $v );
284 delete($v->{subfields}) if (defined($v->{subfields}));
288 foreach my $sf (keys %{ $v }) {
290 $subfields->{ $sf }++;
292 # is non-repeatable but with multiple values?
293 if ( ! first { $_ eq $sf.'*' } @{$r->{$f}} ) {
294 if ( ref($v->{$sf}) eq 'ARRAY' ) {
295 $sf_repeatable->{$sf}++;
297 if (! defined first { $_ eq $sf } @{ $r->{$f} }) {
298 $errors->{ $f }->{subfield}->{extra}->{$sf}++;
303 if (my @r_sf = sort keys( %$sf_repeatable )) {
305 foreach my $sf (@r_sf) {
306 $errors->{$f}->{subfield}->{extra_repeatable}->{$sf}++;
307 $errors->{$f}->{dump} = _pack_subfields_hash( $h, 1 );
312 if ( defined( $self->{must_exist_sf}->{$f} ) ) {
313 foreach my $sf (sort keys %{ $self->{must_exist_sf}->{$f} }) {
314 #warn "====> $f $sf must exist\n";
315 $errors->{$f}->{subfield}->{missing}->{$sf}++
316 unless defined( $subfields->{$sf} );
321 } elsif (ref($v) eq 'HASH') {
322 $errors->{$f}->{unexpected_subfields}++;
323 $errors->{$f}->{dump} = _pack_subfields_hash( $v, 1 );
328 $log->debug("_delimiters_templates = ", sub { dump( $self->{_delimiters_templates} ) } );
330 foreach my $must (sort keys %{ $self->{must_exist} }) {
331 next if ($fields->{$must});
332 $errors->{$must}->{missing}++;
333 $errors->{dump} = $rec_dump if ($rec_dump);
337 $log->debug("errors: ", $self->report_error( $errors ) );
339 my $mfn = $rec->{'000'}->[0] || $log->logconfess("record ", sub { dump( $rec ) }, " doesn't have MFN");
340 $self->{errors}->{$mfn} = $errors;
343 #$log->logcluck("return from this function is ARRAY") unless wantarray;
350 Clean all accumulated errors for this input and remember delimiter templates
351 for L<save_delimiters_templates>
355 This function B<must> be called after each input to provide accurate statistics.
362 my $log = $self->_get_logger;
364 delete ($self->{errors});
366 if ( ! $self->{_delimiters_templates} ) {
367 $log->debug("called without _delimiters_templates?");
371 foreach my $f ( keys %{ $self->{_delimiters_templates} } ) {
372 foreach my $t ( keys %{ $self->{_delimiters_templates}->{$f} } ) {
373 $self->{_accumulated_delimiters_templates}->{$f}->{$t} +=
374 $self->{_delimiters_templates}->{$f}->{$t};
377 $log->debug("_accumulated_delimiters_templates = ", sub { dump( $self->{_accumulated_delimiters_templates} ) } );
378 delete ($self->{_delimiters_templates});
383 Return hash with all errors
385 print dump( $validate->all_errors );
391 return $self->{errors};
396 Produce nice humanly readable report of single error
398 print $validate->report_error( $error_hash );
405 my $h = shift || die "no hash?";
408 my ($self, $tree, $accumulated) = @_;
410 my $log = $self->_get_logger();
413 ( $tree ? "tree: $tree " : '' ),
414 ( $accumulated ? "accumulated: $accumulated " : '' ),
419 if (ref($tree) ne 'HASH') {
420 return ("$accumulated\t($tree)", undef);
425 foreach my $k (sort keys %{ $tree }) {
428 $dump = $tree->{dump};
429 #warn "## dump ",dump($dump),"\n";
433 $log->debug("current: $k");
435 my ($new_results, $new_dump) = $self->_unroll($tree->{$k},
436 $accumulated ? "$accumulated\t$k" : $k
439 $log->debug( "new_results: ", sub { dump($new_results) } ) if ( $new_results );
441 push @$results, $new_results if ($new_results);
442 $dump = $new_dump if ($new_dump);
446 $log->debug( "results: ", sub { dump($results) } ) if ( $results );
448 if ($#$results == 0) {
449 return ($results->[0], $dump);
451 return ($results, $dump);
465 for my $f (sort keys %{ $h }) {
468 my ($r, $d) = $self->_unroll( $h->{$f} );
470 if (ref($r) eq 'ARRAY') {
471 $e .= join(", ", map { _reformat( $_ ) } @$r);
473 $e .= _reformat( $r );
475 $e .= "\n\t$d" if ($d);
485 Produce nice humanly readable report of errors
487 print $validate->report;
493 my $e = $self->{errors} || return;
496 foreach my $mfn (sort { $a <=> $b } keys %$e) {
497 $out .= "MFN $mfn\n" . $self->report_error( $e->{$mfn} ) . "\n";
504 =head2 delimiters_templates
506 Generate report of delimiter tamplates
508 my $report = $validate->delimiter_teplates(
519 Generate humanly readable report with single fields
523 Report just current_input and not accumulated data
529 sub delimiters_templates {
534 my $t = $self->{_accumulated_delimiters_templates};
535 $t = $self->{_delimiters_templates} if ( $args->{current_input} );
537 my $log = $self->_get_logger;
540 $log->error("called without delimiters");
546 foreach my $f (sort { $a <=> $b } keys %$t) {
547 $out .= "$f\n" if ( $args->{report} );
548 foreach my $template (sort { $a cmp $b } keys %{ $t->{$f} }) {
549 my $count = $t->{$f}->{$template};
551 ( $count ? "" : "# " ) .
552 ( $args->{report} ? "" : "$f" ) .
553 "\t$count\t$template\n";
560 =head2 save_delimiters_templates
562 Save accumulated delimiter templates
564 $validator->save_delimiters_template( '/path/to/validate/delimiters' );
568 sub save_delimiters_templates {
572 $path ||= $self->{delimiters_path};
574 my $log = $self->_get_logger;
576 $log->logdie("need path") unless ( $path );
579 if ( ! $self->{_accumulated_delimiters_templates} ) {
580 $log->error('no _accumulated_delimiters_templates found, reset');
584 if ( $self->{_delimiters_templates} ) {
585 $log->error('found _delimiters_templates, calling reset');
589 $path .= '.new' if ( -e $path );
591 open(my $d, '>', $path) || $log->fatal("can't open $path: $!");
592 print $d $self->delimiters_templates;
595 $log->info("new delimiters templates saved to $path");
602 Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>
604 =head1 COPYRIGHT & LICENSE
606 Copyright 2006 Dobrica Pavlinusic, All Rights Reserved.
608 This program is free software; you can redistribute it and/or modify it
609 under the same terms as Perl itself.
613 1; # End of WebPAC::Validate