use strict;
use XML::Twig;
-use Equinox::Migration::SubfieldMapper;
+use Equinox::Migration::SubfieldMapper 1.003;
+
=head1 NAME
my $m = Equinox::Migration::MapDrivenMARCXMLProc->new( mapfile => FILE,
marcfile => FILE );
-There is an optional third, argument, C<sample>, which specifies a
-arrayref of datafields to "sample" by reporting on subfields which are
-found in the data but not in the map.
-
- my $m = Equinox::Migration::MapDrivenMARCXMLProc->new( mapfile => FILE,
- marcfile => FILE,
- sample => \@TAGS
- );
-
-See L</UNMAPPED TAGS> for more info.
-
=cut
sub new {
my ($class, %args) = @_;
my $self = bless { mods => { multi => {},
- once => {},
+ bib => {},
required => {},
},
data => { recs => undef, # X::T record objects
rptr => 0, # next record pointer
crec => undef, # parsed record storage
- stag => undef, # list of tags to sample
- umap => undef, # unmapped data samples
+ tmap => undef, # tag_id-to-tag array map
},
}, $class;
# get the next record and wipe current parsed record
return 0 unless defined $self->{data}{recs}[ $self->{data}{rptr} ];
my $record = $self->{data}{recs}[ $self->{data}{rptr} ];
- $self->{data}{crec} = { egid => undef, bib => undef, tags => undef };
+ $self->{data}{crec} = { egid => undef, tags => undef };
+ $self->{data}{tmap} = {};
my @fields = $record->children;
for my $f (@fields)
$record->purge;
$self->{data}{rptr}++;
+ # check for required fields
+ $self->check_required;
+
return $self->{data}{crec};
}
-=head2 process_field
-
-=cut
-
sub process_field {
my ($self, $field) = @_;
my $map = $self->{map};
my $tag = $field->{'att'}->{'tag'};
my $crec = $self->{data}{crec};
+ my $tmap = $self->{data}{tmap};
+
+ # leader
+ unless (defined $tag) {
+ #FIXME
+ return;
+ }
# datafields
- if (defined $tag) {
- if ($tag == 903) {
- my $sub = $field->first_child('subfield');
- $crec->{egid} = $sub->text;;
- } elsif ($map->has($tag)) {
- push @{$crec->{tags}}, { tag => $tag, uni => undef, multi => undef };
- my @subs = $field->children('subfield');
- for my $sub (@subs)
- { $self->process_subs($tag, $sub) }
- # check map to ensure all declared subs are in
+ if ($tag == 903) {
+ my $sub = $field->first_child('subfield');
+ $crec->{egid} = $sub->text;
+ return;
+ }
+ if ($map->has($tag)) {
+ push @{$crec->{tags}}, { tag => $tag, uni => undef, multi => undef };
+ push @{$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
+ 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};
}
}
}
-=head2 process_subs
-
-=cut
-
sub process_subs {
my ($self, $tag, $sub) = @_;
my $map = $self->{map};
my $code = $sub->{'att'}->{'code'};
# handle unmapped tag/subs
- unless ($map->has($tag, $code)) {
- my $u = $self->{data}{umap};
- my $s = $self->{data}{stag};
- return unless (defined $s->{$tag});
-
- # set a value, total-seen count and records-seen-in count
- $u->{$tag}{$code}{value} = $sub->text unless defined $u->{$tag}{$code};
- $u->{$tag}{$code}{count}++;
- $u->{$tag}{$code}{rcnt}++ unless ($u->{$tag}{$code}{last} == $self->{data}{rptr});
- $u->{$tag}{$code}{last} = $self->{data}{rptr};
- return;
- }
+ return unless ($map->has($tag, $code));
+ # fetch our datafield struct and fieldname
my $dataf = $self->{data}{crec}{tags}[-1];
my $field = $map->field($tag, $code);
- # handle modifiers
- if (defined $map->mods($field)) {
- if ($map->mods($field) eq 'multi') {
+ # test filters
+ for my $filter ( @{$map->filters($field)} ) {
+ return if ($sub->text =~ /$filter/i);
+ }
+ # handle multi modifier
+ if (my $mods = $map->mods($field)) {
+ if ($mods->{multi}) {
my $name = $tag . $code;
push @{$dataf->{multi}{$name}}, $sub->text;
+ return;
}
}
+ # if this were a multi field, it would be handled already. make sure its a singleton
+ die "Multiple occurances of a non-multi field: $tag$code at rec ",
+ ($self->{data}{rptr} + 1),"\n" if (defined $dataf->{uni}{$code});
+
+ # everything seems okay
$dataf->{uni}{$code} = $sub->text;
}
+
+sub check_required {
+ my ($self) = @_;
+ my $mods = $self->{map}->mods;
+ my $crec = $self->{data}{crec};
+
+ for my $tag_id (keys %{$mods->{required}}) {
+ for my $code (@{$mods->{required}{$tag_id}}) {
+ my $found = 0;
+
+ for my $tag (@{$crec->{tags}}) {
+ $found = 1 if ($tag->{multi}{($tag_id . $code)});
+ $found = 1 if ($tag->{uni}{$code});
+ }
+
+ die "Required mapping $tag_id$code not found in rec ",$self->{data}{rptr},"\n"
+ unless ($found);
+ }
+ }
+
+}
+
+=head1 MODIFIERS
+
+MapDrivenMARCXMLProc implements the following modifiers, and passes
+them to L<Equinox::Migration::SubfieldMapper>, meaning that specifying
+any other modifiers in a MDMP map file will cause a fatal error when
+it is processed.
+
+=head2 multi
+
+If a mapping is declared to be C<multi>, then MDMP expects to see more
+than one instance of that subfield per datafield, and the data is
+handled accordingly (see L</PARSED RECORDS> below).
+
+Occurring zero or one time is legal for a C<multi> mapping.
+
+A mapping which is not flagged as C<multi>, but which occurs more than
+once per datafield will cause a fatal error.
+
+=head2 required
+
+By default, if a mapping does not occur in a datafield, processing
+continues normally. if a mapping has the C<required> modifier,
+however, it must appear, or a fatal error will occur.
+
=head1 PARSED RECORDS
+Given:
+
+ my $m = Equinox::Migration::MapDrivenMARCXMLProc->new(ARGUMENTS);
+ $rec = $m->parse_record;
+
+Then C<$rec> will look like:
+
{
- egid => evergreen_record_id,
- bib => {
- (tag_id . sub_code)1 => value1,
- (tag_id . sub_code)2 => value2,
- ...
- },
+ egid => evergreen_record_id,
tags => [
{
tag => tag_id,
}
That is, there is an C<egid> key which points to the Evergreen ID of
-that record, a C<bib> key which points to a hashref, and a C<tags>
-key which points to an arrayref.
-
-=head3 C<bib>
-
-This hashref holds extracted data which should occur once per record
-(the default assumption is that a tag/subfield pair can occur multiple
-times per record). The keys are composed of tag id and subfield code,
-catenated (e.g. 901c). The values are the contents of that subfield of
-that tag.
-
-If there are no tags defined as bib-level, C<bib> will be C<undef>.
+that record, and a C<tags> key which points to an arrayref.
=head3 C<tags>
-This arrayref holds anonymous hashrefs, one for each instance of each
-tag which occurs in the map. Each tag hashref holds its own id
-(e.g. C<998>), and two more hashrefs, C<multi> and C<uni>.
+A reference to a list of anonymous hashes, one for each instance of
+each tag which occurs in the map.
+
+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> hashref holds the extracted data for tag/sub mappings
-which have the C<multiple> modifier on them. The keys in C<multi> are
+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
-instances of that subfield in that instance of that tag.
+instances of that subfield in that instance of that tag. If no tags
+are defined as C<multi>, it will be C<undef>.
-The C<uni> hashref holds data for tag/sub mappings which occur only
-once per instance of a tag (but may occur multiple times in a record
-due to there being multiple instances of that tag in a record). Keys
-are subfield codes and values are subfield content.
+The C<uni> hash holds data for tag/sub mappings which occur only once
+per instance of a tag (but may occur multiple times in a record due to
+there being multiple instances of that tag in a record). Keys are
+subfield codes and values are subfield content.
-If no tags are defined as C<multi>, it will be C<undef>.
+All C<uni> subfields occuring in the map are guaranteed to be
+defined. Sufields which are mapped but do not occur in a particular
+datafield will be given a value of '' (the null string) in the current
+record struct. Oppose subfields which are not mapped, which will be
+C<undef>.
-=head1 UNMAPPED TAGS
-
- { tag_id => {
- sub_code => { value => VALUE, count => COUNT },
- sub_code2 => { value => VALUE, count => COUNT },
- ...
- },
- ...
- }
=head1 AUTHOR
projects / migration-tools.git / blobdiff