r932@llin: dpavlin | 2006-09-11 14:31:51 +0200

 simplify errors return hash, a bit better formatting of report

git-svn-id: svn+ssh://mjesec/home/dpavlin/svn/webpac2/trunk@666 07558da8-63fa-0310-ba24-9fe276d99e06

diff --git a/conf/log.conf b/conf/log.conf
index 2c4623f..ccaf7aa 100644 (file)
--- a/conf/log.conf
+++ b/conf/log.conf
@@ -20,6 +20,7 @@ log4perl.rootLogger=INFO, LOG, SCREEN
 #log4perl.logger.WebPAC.Lookup.lookup=DEBUG
 
 #log4perl.logger.WebPAC.Validate=DEBUG
+log4perl.logger.WebPAC.Validate.report=DEBUG
 
 #log4perl.logger.WebPAC.Input=DEBUG
 #log4perl.logger.WebPAC.Input.modify_record_regexps=DEBUG

diff --git a/lib/WebPAC/Validate.pm b/lib/WebPAC/Validate.pm
index b417e99..83ba782 100644 (file)
--- a/lib/WebPAC/Validate.pm
+++ b/lib/WebPAC/Validate.pm
@@ -145,13 +145,13 @@ sub validate_errors {
                $fields->{$f}++;
 
                if ( ! defined($r->{$f}) ) {
-                       $errors->{field}->{ $f }->{unexpected} = "this field is not expected";
+                       $errors->{ $f }->{unexpected} = "this field is not expected";
                        next;
                }
 
 
                if (ref($rec->{$f}) ne 'ARRAY') {
-                       $errors->{field}->{ $f }->{not_repeatable} = "probably bug in parsing input data";
+                       $errors->{ $f }->{not_repeatable} = "probably bug in parsing input data";
                        next;
                }
 
@@ -160,10 +160,10 @@ sub validate_errors {
                        if (ref($r->{$f}) eq 'ARRAY') {
                                # are values hashes? (has subfields)
                                if (! defined($v)) {
-#                                      $errors->{field}->{$f}->{empty} = undef;
+#                                      $errors->{$f}->{empty} = undef;
 #                                      $errors->{dump} = $rec_dump if ($rec_dump);
                                } elsif (ref($v) ne 'HASH') {
-                                       $errors->{field}->{$f}->{missing_subfield} = join(",", @{ $r->{$f} }) . " required";
+                                       $errors->{$f}->{missing_subfield} = join(",", @{ $r->{$f} }) . " required";
                                        next;
                                } else {
 
@@ -185,7 +185,7 @@ sub validate_errors {
                                                                $sf_repeatable->{$sf}++;
                                                        };
                                                        if (! first { $_ eq $sf } @{ $r->{$f} }) {
-                                                               $errors->{field}->{ $f }->{subfield}->{extra}->{$sf}++;
+                                                               $errors->{ $f }->{subfield}->{extra}->{$sf}++;
                                                        }
                                                }
 
@@ -193,8 +193,8 @@ sub validate_errors {
                                        if (my @r_sf = sort keys( %$sf_repeatable )) {
 
                                                foreach my $sf (@r_sf) {
-                                                       $errors->{field}->{$f}->{subfield}->{extra_repeatable}->{$sf}++;
-                                                       $errors->{field}->{$f}->{dump} =
+                                                       $errors->{$f}->{subfield}->{extra_repeatable}->{$sf}++;
+                                                       $errors->{$f}->{dump} =
                                                                join('', _pack_subfields_hash( $h, 1 ) );
                                                }
 
@@ -203,15 +203,15 @@ sub validate_errors {
                                        if ( defined( $self->{must_exist_sf}->{$f} ) ) {
                                                foreach my $sf (sort keys %{ $self->{must_exist_sf}->{$f} }) {
 #warn "====> $f $sf must exist\n";
-                                                       $errors->{field}->{$f}->{subfield}->{missing}->{$sf}++
+                                                       $errors->{$f}->{subfield}->{missing}->{$sf}++
                                                                unless defined( $subfields->{$sf} );
                                                }
                                        }
 
                                }
                        } elsif (ref($v) eq 'HASH') {
-                               $errors->{field}->{$f}->{unexpected_subfields}++;
-                               $errors->{field}->{$f}->{dump} =
+                               $errors->{$f}->{unexpected_subfields}++;
+                               $errors->{$f}->{dump} =
                                        join('', _pack_subfields_hash( $v, 1 ) );
                        }
                }
@@ -219,7 +219,7 @@ sub validate_errors {
 
        foreach my $must (sort keys %{ $self->{must_exist} }) {
                next if ($fields->{$must});
-               $errors->{field}->{$must}->{missing}++;
+               $errors->{$must}->{missing}++;
                $errors->{dump} = $rec_dump if ($rec_dump);
        }
 
@@ -272,10 +272,10 @@ Produce nice humanly readable report of errors
 sub report {
        my $self = shift;
 
-       my $log = $self->_get_logger();
-
        sub unroll {
-               my ($tree, $accumulated) = @_;
+               my ($self, $tree, $accumulated) = @_;
+
+               my $log = $self->_get_logger();
 
                $log->debug("# ",
                        ( $tree                 ? "tree: $tree "                                        : '' ),
@@ -294,13 +294,13 @@ sub report {
 
                        if ($k eq 'dump') {
                                $dump = $tree->{dump};
-                               warn "## dump: $dump\n";
+                               warn "## dump: ",dump($dump),"\n";
                                next;
                        }
 
                        $log->debug("current: $k");
 
-                       my ($new_results, $new_dump) = unroll($tree->{$k},
+                       my ($new_results, $new_dump) = $self->unroll($tree->{$k},
                                $accumulated ? "$accumulated\t$k" : $k
                        );
 
@@ -324,12 +324,34 @@ sub report {
                }
        }
 
+       my $log = $self->_get_logger();
+
        my $out = '';
        my $e = $self->{errors} || return;
 
+       sub reformat {
+               my $l = shift;
+               $l =~ s/\t/ /g;
+               $l =~ s/_/ /;
+               return $l;
+       }
+
        foreach my $mfn (sort keys %$e) {
-               my ($r, $d) = unroll( $e->{$mfn} );
-               $out .= "MFN $mfn\n", dump($r), "\t$d\n\n";
+               $out .= "MFN $mfn\n";
+
+               for my $f (sort keys %{ $e->{$mfn} }) {
+                       my ($r, $d) = $self->unroll( $e->{$mfn}->{$f} );
+                       my $e = $f . ': ';
+                       if (ref($r) eq 'ARRAY') {
+                               $e .= join(", ", map { reformat( $_ ) } @$r);
+                       } else {
+                               $e .= reformat( $r );
+                       }
+                       $e .= "\n\t$d" if ($d);
+                       $e .= "\n";
+                       $log->debug("MFN $mfn | $e");
+                       $out .= $e;
+               }
        }
 
        return $out;

diff --git a/t/1-validate.t b/t/1-validate.t
index 05728cb..3187c38 100755 (executable)
--- a/t/1-validate.t
+++ b/t/1-validate.t
@@ -21,6 +21,7 @@ throws_ok { new WebPAC::Validate( no_log => 1 ) } qr/need path/, "new without pa
 
 ok(my $v = new WebPAC::Validate(
        path => "$abs_path/data/validate_test",
+       debug => $debug,
 ), "new");
 
 ok($v->{rules}, "rules exist");
@@ -73,7 +74,7 @@ sub test_v {
 
 test_v({
        '900' => 'foo'
-}, qw/field 900 not_repeatable/);
+}, qw/900 not_repeatable/);
 
 test_v({
        '900' => [ qw/foo bar baz/ ]
@@ -81,7 +82,7 @@ test_v({
 
 test_v({
        '901' => [ qw/foo bar baz/ ]
-}, qw/field 901 missing_subfield/);
+}, qw/901 missing_subfield/);
 
 test_v({
        '901' => [ { 'a' => 42 } ]
@@ -89,7 +90,7 @@ test_v({
 
 test_v({
        '901' => [ { 'b' => 42 } ]
-}, qw/field 901 subfield extra b/);
+}, qw/901 subfield extra b/);
 
 test_v({
        '902' => [ { 'b' => 1 }, { 'c' => 2 } ]
@@ -97,7 +98,7 @@ test_v({
 
 test_v({
        '902' => [ { 'a' => 0 }, { 'b' => 1 }, { 'c' => 2 } ]
-}, qw/field 902 subfield extra a/);
+}, qw/902 subfield extra a/);
 
 test_v({
        '903' => [ { 'a' => 0 }, { 'b' => 1 }, { 'c' => 2 } ]
@@ -105,13 +106,13 @@ test_v({
 
 test_v({
        '903' => [ { 'a' => 0 }, { 'b' => 1 }, { 'c' => 2 }, { 'd' => 3 } ]
-}, qw/field 903 subfield extra d/);
+}, qw/903 subfield extra d/);
 
 is_deeply(
 
 test_v({
        '903' => [ { 'a' => 0 }, { 'b' => 1 }, { 'c' => 2 }, { 'd' => 3 }, { 'e' => 4 } ]
-}, qw/field 903 subfield extra/),
+}, qw/903 subfield extra/),
 { 'd' => 1, 'e' => 1 }, 'additional fields d, e');
 
 test_v({
@@ -120,11 +121,11 @@ test_v({
 
 test_v({
        '904' => [ { 'b' => 1 } ]
-}, qw/field 904 subfield extra b/);
+}, qw/904 subfield extra b/);
 
 test_v({
        '904' => [ { 'a' => [ 1,2 ] } ]
-}, qw/field 904 subfield extra_repeatable a/);
+}, qw/904 subfield extra_repeatable a/);
 
 test_v({
        '905' => [ { 'a' => [ 1,2 ] } ]
@@ -145,4 +146,4 @@ test_v({
 
 diag "errors: ",dump( $v->all_errors );
 
-print $v->report;
+diag "report: ", $v->report;