multi hash now uses just code for key

[migration-tools.git] / Equinox-Migration / lib / Equinox / Migration / MapDrivenMARCXMLProc.pm

diff --git a/Equinox-Migration/lib/Equinox/Migration/MapDrivenMARCXMLProc.pm b/Equinox-Migration/lib/Equinox/Migration/MapDrivenMARCXMLProc.pm
index b55fdc4..75424ff 100644 (file)
--- a/Equinox-Migration/lib/Equinox/Migration/MapDrivenMARCXMLProc.pm
+++ b/Equinox-Migration/lib/Equinox/Migration/MapDrivenMARCXMLProc.pm
@@ -4,7 +4,7 @@ use warnings;
 use strict;
 
 use XML::Twig;
-use Equinox::Migration::SubfieldMapper 1.003;
+use Equinox::Migration::SubfieldMapper 1.004;
 
 
 =head1 NAME
@@ -13,11 +13,11 @@ Equinox::Migration::MapDrivenMARCXMLProc
 
 =head1 VERSION
 
-Version 1.000
+Version 1.001
 
 =cut
 
-our $VERSION = '1.000';
+our $VERSION = '1.001';
 
 
 =head1 SYNOPSIS
@@ -98,7 +98,7 @@ sub parse_record {
 
     my @fields = $record->children;
     for my $f (@fields)
-      { $self->process_field($f) }
+      { $self->process_field($f); $f->purge; }
 
     # cleanup memory and increment pointer
     $record->purge;
@@ -133,14 +133,19 @@ sub process_field {
         push @{$crec->{tmap}{$tag}}, (@{$crec->{tags}} - 1);
         my @subs = $field->children('subfield');
         for my $sub (@subs)
-          { $self->process_subs($tag, $sub) }
-        # check map to ensure all declared subs have a value
+          { $self->process_subs($tag, $sub); $sub->purge; }
+
+        # check map to ensure all declared tags and subs have a value
         my $mods = $map->mods($field);
         for my $mappedsub ( @{ $map->subfields($tag) } ) {
             next if $mods->{multi};
             $crec->{tags}[-1]{uni}{$mappedsub} = ''
               unless defined $crec->{tags}[-1]{uni}{$mappedsub};
         }
+        for my $mappedtag ( @{ $map->tags }) {
+            $crec->{tmap}{$mappedtag} = undef
+              unless defined $crec->{tmap}{$mappedtag};
+        }
     }
 }
 
@@ -155,6 +160,7 @@ sub process_subs {
     # fetch our datafield struct and fieldname
     my $dataf = $self->{data}{crec}{tags}[-1];
     my $field = $map->field($tag, $code);
+    $self->{data}{crec}{names}{$tag}{$code} = $field;
 
     # test filters
     for my $filter ( @{$map->filters($field)} ) {
@@ -163,8 +169,7 @@ sub process_subs {
     # handle multi modifier
     if (my $mods = $map->mods($field)) {
         if ($mods->{multi}) {
-            my $name = $tag . $code;
-            push @{$dataf->{multi}{$name}}, $sub->text;
+            push @{$dataf->{multi}{$code}}, $sub->text;
             return;
         }
     }
@@ -199,6 +204,24 @@ sub check_required {
 
 }
 
+=head2 recno
+
+Returns current record number (starting from zero)
+
+=cut
+
+sub recno { my ($self) = @_; return $self->{data}{rptr} }
+
+=head2 name
+
+Returns mapped fieldname when pass a tag and code
+
+    my $name = $m->name(999,'a');
+
+=cut
+
+sub name { my ($self, $t, $c) = @_; return $self->{data}{crec}{names}{$t}{$c} };
+
 =head1 MODIFIERS
 
 MapDrivenMARCXMLProc implements the following modifiers, and passes
@@ -237,7 +260,7 @@ Then C<$rec> will look like:
       tags => [
                 {
                   tag   => tag_id,
-                  multi => { (tag_id . sub_code) => [ val1, val2, ... ] },
+                  multi => { code => [ val1, val2, ... ] },
                   uni   => { code => value, code2 => value2, ... },
                 },
                 ...
@@ -258,9 +281,8 @@ Each tag hash holds its own id (e.g. C<998>), and two references to
 two more hashrefs, C<multi> and C<uni>.
 
 The C<multi> hash holds the extracted data for tag/sub mappings which
-have the C<multiple> modifier on them. The keys in C<multi> are
-composed of the tag id and subfield code, catenated
-(e.g. C<901c>). The values are arrayrefs containing the content of all
+have the C<multiple> modifier on them. The keys in C<multi> subfield
+codes.  The values are arrayrefs containing the content of all
 instances of that subfield in that instance of that tag. If no tags
 are defined as C<multi>, it will be C<undef>.