marc_cleanup

   1 #!/usr/bin/perl
   2
   3 # Copyright 2009-2012, Equinox Software, Inc.
   4 #
   5 # This program is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU General Public License
   7 # as published by the Free Software Foundation; either version 2
   8 # of the License, or (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18
  19 require 5.10.0;
  20
  21 use strict;
  22 use warnings;
  23
  24 use Getopt::Long;
  25 use Term::ReadLine;
  26 use Equinox::Migration::SimpleTagList;
  27
  28 my $term = new Term::ReadLine 'yaz-cleanup';
  29 my $OUT = $term->OUT || \*STDOUT;
  30 binmode STDOUT, ":utf8";
  31 binmode $OUT, ":utf8";
  32
  33 $| = 1;
  34
  35 # initialization and setup
  36 my $c = {};
  37 initialize($c);
  38
  39 # set up files, since everything appears to be in order
  40 open MARC, '<:utf8', $c->{marcfile}
  41   or die "Can't open input file $!\n";
  42 open my $NUMARC, '>:utf8', $c->{output}
  43   or die "Can't open output file $!\n";
  44 open my $OLD2NEW, '>', 'old2new.map'
  45   if ($c->{'renumber-from'} and $c->{'original-tag'});
  46 my $EXMARC = 'EX';
  47 print $NUMARC "<collection xmlns=\"http://www.loc.gov/MARC21/slim\">\n";
  48
  49 $c->{totalrecs} = `grep -c '<record' $c->{marcfile}`;
  50 chomp $c->{totalrecs};
  51 $c->{percent}   = 0;
  52
  53 my @record;  # current record storage
  54 my %recmeta; # metadata about current record
  55 my $ptr = 0; # record index pointer
  56
  57 # this is the dispatch table which drives command selection in
  58 # edit(), below
  59 my %commands = ( c => \&print_fullcontext,
  60                  n => \&next_line,
  61                  p => \&prev_line,
  62                  '<' => \&widen_window,
  63                  '>' => \&narrow_window,
  64                  d => \&display_lines,
  65                  o => \&insert_original,
  66                  k => \&kill_line,
  67                  y => \&yank_line,
  68                  f => \&flip_line,
  69                  m => \&merge_lines,
  70                  s => \&substitute,
  71                  t => \&commit_edit,
  72                  x => \&dump_record,
  73                  q => \&quit,
  74                  '?' => \&help,
  75                  h   => \&help,
  76                  help => \&help,
  77                );
  78
  79 my @spinner = qw(- \\ | /);
  80 my $sidx = 0;
  81
  82 while ( buildrecord() ) {
  83     unless ($c->{ricount} % 50) {
  84         $c->{percent} = int(($c->{ricount} / $c->{totalrecs}) * 100);
  85         print "\rWorking (",$c->{percent},"%) ", $spinner[$sidx];
  86         $sidx = ($sidx == $#spinner) ? 0 : $sidx + 1;
  87     }
  88
  89     my $rc = do_automated_cleanups();
  90     next if $rc;
  91
  92     $ptr = 0;
  93     until ($ptr == $#record) {
  94         # get datafield/tag data if we have it
  95         $rc = stow_record_data() if ($c->{'renumber-from'} and $c->{'original-tag'});
  96         next if $rc;
  97
  98         # naked ampersands
  99         if ($record[$ptr] =~ /&/ && $record[$ptr] !~ /&\w+?;/)
 100           { edit("Naked ampersand"); $ptr= 0; next }
 101
 102         if ($record[$ptr] =~ /<datafield tag="(.+?)"/) {
 103             my $match = $1;
 104             # tags must be numeric
 105             if ($match =~ /\D/) {
 106                 edit("Non-numerics in tag") unless $c->{autoscrub};
 107                 next;
 108             }
 109         }
 110
 111         # subfields can't be non-alphanumeric
 112         if ($record[$ptr] =~ /<subfield code="(.*?)"/) {
 113             if ($1 =~ /\P{IsAlnum}/ or $1 eq '') {
 114                 edit("Junk in subfield code/Null subfield code ($1)");
 115                 next;
 116             }
 117         }
 118         # subfields can't be larger than 1 char (technically you could make the MARC format accomodate that:)
 119         if ($record[$ptr] =~ /<subfield code="(\w{2,})"/) {
 120             edit("Subfield code larger than 1 char");
 121             next;
 122         }
 123
 124         $ptr++;
 125     }
 126     write_record($NUMARC);
 127 }
 128 print $NUMARC "</collection>\n";
 129 print $OUT "\nDone. ",$c->{ricount}," in; ",$c->{rocount}," dumped          \n";
 130
 131
 132 #-----------------------------------------------------------------------------------
 133 # cleanup routines
 134 #-----------------------------------------------------------------------------------
 135
 136 sub do_automated_cleanups {
 137     $ptr = 0;
 138     until ($ptr == $#record) {
 139
 140         # catch empty datafield elements
 141         if ($record[$ptr] =~ m/<datafield tag="..."/) {
 142             if ($record[$ptr + 1] =~ m|</datafield>|) {
 143                 my @a = @record[0 .. $ptr - 1];
 144                 my @b = @record[$ptr + 2 .. $#record];
 145                 @record = (@a, @b);
 146                 @a = undef; @b = undef;
 147                 message("Empty datafield scrubbed");
 148                 $ptr = 0;
 149                 next;
 150             }
 151         }
 152         # and quasi-empty subfields
 153         if ($record[$ptr] =~ m|<subfield code="(.*?)">(.*?)</sub|) {
 154             my $code = $1; my $content = $2;
 155             if ($code =~ /\W/ and ($content =~ /\s+/ or $content eq '')) {
 156                 my @a = @record[0 .. $ptr - 1];
 157                 my @b = @record[$ptr + 1 .. $#record];
 158                 @record = (@a, @b);
 159                 @a = undef; @b = undef;
 160                 message("Empty subfield scrubbed");
 161                 $ptr = 0;
 162                 next;
 163             }
 164         }
 165         $ptr++;
 166     }
 167
 168     # single-line fixes
 169     for $ptr (0 .. $#record) {
 170         # pad short leaders
 171         if ($record[$ptr] =~ m|<leader>(.+?)</leader>|) {
 172             my $leader = $1;
 173             if (length $leader < 24) {
 174                 $leader .= ' ' x (20 - length($leader));
 175                 $leader .= "4500";
 176                 $record[$ptr] = "<leader>$leader</leader>\n";
 177                 message("Short leader padded");
 178             }
 179         }
 180         if ($c->{'force-utf8'}) {
 181             if ($record[$ptr] =~ m|<leader>(.........).(.+)</leader>|) {
 182                 $record[$ptr] = "<leader>$1a$2</leader>\n";
 183             }
 184         }
 185         if ($record[$ptr] =~ m|<controlfield tag="008">(.+?)</control|) {
 186             #pad short 008
 187             my $content = $1;
 188             if (length $content < 40) {
 189                 $content .= ' ' x (40 - length($content));
 190                 $record[$ptr] = "<controlfield tag=\"008\">$content</controlfield>\n";
 191                 message("Short 008 padded");
 192             }
 193         }
 194
 195         # clean misplaced dollarsigns
 196         if ($record[$ptr] =~ m|<subfield code="\$">c?\d+\.\d{2}|) {
 197             $record[$ptr] =~ s|"\$">c?(\d+\.\d{2})|"c">\$$1|;
 198             message("Dollar sign corrected");
 199         }
 200
 201         # excessive trailing whitespace in subfield contents
 202         if ($record[$ptr] =~ m|\s{10,}</subfield>|) {
 203             $record[$ptr] =~ s|\s{10,}</subfield>|</subfield>|;
 204             message("Trailing whitespace trimmed from subfield contents");
 205         }
 206
 207         # automatable subfield maladies
 208         if ($record[$ptr] =~ /code=" ">c/) {
 209             message('Fixing probable subfield c, scenario 1');
 210             $record[$ptr] =~ s/code=" ">c/code="c">/;
 211         }
 212         if ($record[$ptr] =~ /code=" ">\$/) {
 213             message('Fixing probable subfield c, scenario 2');
 214             $record[$ptr] =~ s/code=" ">\$/code="c">\$/;
 215         }
 216
 217         if ($c->{'fix-subfield'}) {
 218             if ($record[$ptr] =~ /code="&amp;">/) {
 219                 message('Fixing &amp; for subfield code');
 220                 $record[$ptr] =~ s/code="&amp;">/code="$c->{'fix-subfield'}">/;
 221             }
 222             if ($record[$ptr] =~ /code="(.*?\P{IsAlnum}.*?)">/) {
 223                 message("Fixing non-alphanumeric subfield code: $1 -> " . $c->{'fix-subfield'});
 224                 $record[$ptr] =~ s/code=".*?\P{IsAlnum}.*?">/code="$c->{'fix-subfield'}">/;
 225             }
 226             if ($record[$ptr] =~ /code="">/) {
 227                 message('Fixing null subfield code');
 228                 $record[$ptr] =~ s/code="">/code="$c->{'fix-subfield'}">/;
 229             }
 230         }
 231     }
 232     return 0;
 233 }
 234
 235 sub stow_record_data {
 236     # get tag data if we're looking at it
 237     my $tag = 0;
 238     if ($record[$ptr] =~ m/<(?:control|data)field tag="(.{3})"/) {
 239         $recmeta{tag} = $1;
 240         $tag = $recmeta{tag};
 241         $record[$ptr] =~ m/ind1="(.)"/;
 242         $recmeta{ind1} = $1 || '';
 243         $record[$ptr] =~ m/ind2="(.)"/;
 244         $recmeta{ind2} = $1 || '';
 245
 246         unless ($tag) {
 247             message("Autokill record: no detectable tag");
 248             dump_record("No detectable tag") ;
 249             return 1;
 250         }
 251
 252         # and since we are looking at a tag, see if it's the original id
 253         if ($tag == $c->{'original-tag'}) {
 254             my $oid = 0;
 255             if ($tag < 10) {
 256                 # controlfield
 257                 if ($record[$ptr] =~ m|<controlfield tag="$tag">(.+?)</controlfield>|)
 258                       { $oid = $1; print $OLD2NEW "$oid\t", $recmeta{nid}, "\n" }
 259             } elsif ($tag >= 10 and $c->{'original-subfield'}) {
 260                 # datafield
 261                 my $line = $record[$ptr]; my $lptr = $ptr;
 262                 my $osub = $c->{'original-subfield'};
 263                 # skim to end of this tag
 264                 until ($line =~ m|</datafield>|) {
 265                     if ($line =~ /<subfield code="$osub">(.+?)</)
 266                       { $oid = $1; print $OLD2NEW "$oid\t", $recmeta{nid}, "\n" }
 267                     $lptr++;
 268                     $line = $record[$lptr];
 269                 }
 270             } else {
 271                 return 0;
 272             }
 273
 274             # didn't find the old id!
 275             unless ($oid) {
 276                 message("Autokill record: no oldid when old2new mapping requested");
 277                 dump_record("No old id found");
 278                 return 1;
 279             }
 280
 281             # got it; write to old->new map file
 282             if ($c->{'renumber-from'} and $c->{'original-subfield'}) {
 283             }
 284
 285         }
 286     }
 287     return 0;
 288 }
 289
 290 #-----------------------------------------------------------------------------------
 291 # driver routines
 292 #-----------------------------------------------------------------------------------
 293
 294 =head2 edit
 295
 296 Handles the Term::ReadLine loop
 297
 298 =cut
 299
 300 sub edit {
 301     my ($msg) = @_;
 302
 303     return if $c->{trash}->has( $recmeta{tag} );
 304     if ( $c->{fullauto} )
 305     { dump_record($msg); return }
 306
 307     $c->{editmsg} = $msg;
 308     print_fullcontext();
 309
 310     # stow original problem line
 311     $recmeta{origline} = $record[$ptr];
 312
 313     while (1) {
 314         my $line = $term->readline('marc-cleanup>');
 315         my @chunks = split /\s+/, $line;
 316
 317         # lines with single-character first chunks are commands.
 318         # make sure they exist.
 319         if (length $chunks[0] == 1) {
 320             unless (defined $commands{$chunks[0]}) {
 321                 print $OUT "No such command '", $chunks[0], "'\n";
 322                 next;
 323             }
 324         }
 325
 326         if (defined $commands{$chunks[0]}) {
 327             my $term = $commands{$chunks[0]}->(@chunks[1..$#chunks]);
 328             last if $term;
 329         } else {
 330             $recmeta{prevline} = $record[$ptr];
 331             $record[$ptr] = "$line\n";
 332             print_context();
 333         }
 334     }
 335     # set pointer to top on the way out
 336     $ptr = 0;
 337 }
 338
 339 =head2 buildrecord
 340
 341 Constructs record arrays from the incoming MARC file and returns them
 342 to the driver loop.
 343
 344 =cut
 345
 346 sub buildrecord {
 347     my $l = '';
 348     my $istrash = 0;
 349     my $trash = $c->{trash};
 350
 351     $l = <MARC> while (defined $l and $l !~ /<record/);
 352     return $l unless defined $l;
 353     $c->{ricount}++;
 354
 355     for (keys %recmeta) { $recmeta{$_} = undef }
 356     for (0 .. @record)  { delete $record[$_] }
 357
 358     my $i = 0;
 359     until ($l =~ m|</record>|) {
 360         # clean up tags with spaces in them
 361         $l =~ s/tag="  /tag="00/g;
 362         $l =~ s/tag=" /tag="0/g;
 363         $l =~ s/tag="-/tag="0/g;
 364         $l =~ s/tag="(\d\d) /tag="0$1/g;
 365
 366         # excise unwanted tags
 367         if ($istrash) {
 368             $istrash = 0 if ($l =~ m|</datafield|);
 369             $l = <MARC>;
 370             next;
 371         }
 372         if ($l =~ m/<datafield tag="(.{3})"/) {
 373             if ($trash->has($1) or ($c->{autoscrub} and $1 =~ /\D/))
 374               { $istrash = 1; next }
 375         }
 376
 377         push @record, $l;
 378         $l = <MARC>;
 379         $i++;
 380     }
 381
 382     # add 903(?) with new record id
 383     if ($c->{'renumber-from'}) {
 384         $recmeta{nid} = $c->{'renumber-from'};
 385         push @record, join('', ' <datafield tag="', $c->{'renumber-tag'},
 386                            '" ind1=" " ind2=" "> <subfield code="',
 387                            $c->{'renumber-subfield'},
 388                            '">',
 389                            $recmeta{nid},
 390                            "</subfield></datafield>\n");
 391         $c->{'renumber-from'}++;
 392     }
 393     $i++;
 394
 395     push @record, $l;
 396     return 1;
 397 }
 398
 399 sub write_record {
 400     my ($FH) = @_;
 401
 402     if ($FH eq 'EX') {
 403         $EXMARC = undef;
 404         open $EXMARC, '>:utf8', $c->{exception}
 405           or die "Can't open exception file $!\n";
 406         $FH = $EXMARC;
 407     }
 408
 409     print $FH '<!-- ', $recmeta{explanation}, " -->\n"
 410       if(defined $recmeta{explanation});
 411
 412     # scrub newlines (unless told not to or writing exception record)
 413     unless ($c->{nocollapse} or $FH eq $EXMARC)
 414       { s/\n// for (@record) }
 415
 416     # actually write the record
 417     print $FH @record,"\n";
 418
 419     # increment output record count (if not exception)
 420     $c->{rocount}++ if ($FH eq $EXMARC);
 421
 422     # if we were dumping to exception file, nuke the record and set ptr
 423     # to terminate processing loop
 424     @record = ('a');
 425     $ptr = 0;
 426 }
 427
 428 sub print_fullcontext {
 429     print $OUT "\r", ' ' x 72, "\n";
 430     print $OUT $c->{editmsg},"\n";
 431     print $OUT "\r    Tag:",$recmeta{tag}, " Ind1:'",
 432       $recmeta{ind1},"' Ind2:'", $recmeta{ind2}, "'";
 433     print $OUT " @ ", $c->{ricount}, "/", $c->{totalrecs};
 434     print_context();
 435     return 0;
 436 }
 437
 438 sub print_context {
 439     my $upper = int($c->{window} / 2) + 1;
 440     my $lower = int($c->{window} / 2) - 1;
 441     my $start = ($ptr - $upper < 0) ? 0 : $ptr - $upper;
 442     my $stop  = ($ptr + $lower > $#record) ? $#record : $ptr + $lower;
 443     print $OUT "\n";
 444     print $OUT '    |', $record[$_] for ($start .. $ptr - 1);
 445     print $OUT '==> |', $record[$ptr];
 446     print $OUT '    |', $record[$_] for ($ptr + 1 .. $stop);
 447     print $OUT "\n";
 448     return 0;
 449 }
 450
 451 sub message {
 452     my ($msg) = @_;
 453     print $OUT "\r$msg at ",$c->{ricount},"/",$c->{totalrecs}, "\n";
 454 }
 455
 456 #-----------------------------------------------------------------------------------
 457 # command routines
 458 #-----------------------------------------------------------------------------------
 459
 460 sub substitute {
 461     my (@chunks) = @_;
 462
 463     my $ofrom = shift @chunks;
 464     if ($ofrom =~ /^'/) {
 465         until ($ofrom =~ /'$/ or !@chunks)
 466           { $ofrom .= join(' ','',shift @chunks) }
 467         $ofrom =~ s/^'//; $ofrom =~ s/'$//;
 468     }
 469     my $to = shift @chunks;
 470     if ($to =~ /^'/) {
 471         until ($to =~ /'$/ or !@chunks)
 472           { $to .= join(' ','',shift @chunks) }
 473         $to =~ s/^'//; $to =~ s/'$//;
 474     }
 475
 476     my $from = '';
 477     for my $char (split(//,$ofrom)) {
 478         $char = "\\" . $char if ($char =~ /\W/);
 479         $from = join('', $from, $char);
 480     }
 481
 482     $recmeta{prevline} = $record[$ptr];
 483     $record[$ptr] =~ s/$from/$to/;
 484     $ofrom = undef; $to = undef; $from = undef;
 485     print_context();
 486     return 0;
 487 }
 488
 489 sub merge_lines {
 490     $recmeta{prevline} = $record[$ptr];
 491     # remove <subfield stuff; extract (probably wrong) subfield code
 492     $record[$ptr] =~ s/^\s*<subfield code="(.*?)">//;
 493     # and move to front of line
 494     $record[$ptr] = join(' ', $1 , $record[$ptr]);
 495     # tear off trailing subfield tag from preceeding line
 496     $record[$ptr - 1] =~ s|</subfield>\n||;
 497     # join current line onto preceeding line
 498     $record[$ptr - 1] = join('', $record[$ptr - 1], $record[$ptr]);
 499     # erase current line
 500     my @a = @record[0 .. $ptr - 1];
 501     my @b = @record[$ptr + 1 .. $#record];
 502     @record = (@a, @b);
 503     # move record pointer to previous line
 504     prev_line();
 505     print_context();
 506     return 0;
 507 }
 508
 509 sub flip_line {
 510     unless ($recmeta{prevline})
 511       { print $OUT "No previously edited line to flip\n"; return }
 512     my $temp = $record[$ptr];
 513     $record[$ptr] = $recmeta{prevline};
 514     $recmeta{prevline} = $temp;
 515     $temp = undef;
 516     print_context();
 517     return 0;
 518 }
 519
 520 sub kill_line {
 521     $recmeta{killline} = $record[$ptr];
 522     my @a = @record[0 .. $ptr - 1];
 523     my @b = @record[$ptr + 1 .. $#record];
 524     @record = (@a, @b);
 525     @a = undef; @b = undef;
 526     print_context();
 527     return 0;
 528 }
 529
 530 sub yank_line {
 531     unless ($recmeta{killline})
 532       { print $OUT "No killed line to yank\n"; return }
 533     my @a = @record[0 .. $ptr - 1];
 534     my @b = @record[$ptr .. $#record];
 535     @record = (@a, $c->{killline}, @b);
 536     @a = undef; @b = undef;
 537     print_context();
 538     return 0;
 539 }
 540
 541 sub insert_original {
 542     $record[$ptr] = $recmeta{origline};
 543     print_context();
 544     return 0;
 545 }
 546
 547 sub display_lines {
 548     print $OUT "\nOrig. edit line  :", $recmeta{origline};
 549     print $OUT "Current flip line:", $recmeta{prevline} if $recmeta{prevline};
 550     print $OUT "Last killed line :", $recmeta{killline} if $recmeta{killline};
 551     print $OUT "\n";
 552     return 0;
 553 }
 554
 555 sub dump_record {
 556     my (@explanation) = @_;
 557     $recmeta{explanation} = join(' ', 'DUMPING RECORD: Tag', $recmeta{tag}, @explanation);
 558     message( $recmeta{explanation} );
 559     write_record($EXMARC);
 560     return 1;
 561 }
 562
 563 sub next_line {
 564     $ptr++ unless ($ptr == $#record);;
 565     print_context();
 566     return 0;
 567 }
 568
 569 sub prev_line {
 570     $ptr-- unless ($ptr == 0);
 571     print_context();
 572     return 0;
 573 }
 574
 575 sub commit_edit { return 1 }
 576
 577 sub widen_window {
 578     if ($c->{window} == 15)
 579       { print $OUT "Window can't be bigger than 15 lines\n"; return }
 580     $c->{window} += 2;
 581     print_context;
 582 }
 583
 584 sub narrow_window {
 585     if ($c->{window} == 5)
 586       { print $OUT "Window can't be smaller than 5 lines\n"; return }
 587     $c->{window} -= 2;
 588     print_context;
 589 }
 590
 591 sub help {
 592 print $OUT <<HELP;
 593 Type a replacement for the indicated line, or enter a command.
 594
 595 DISPLAY COMMANDS             | LINE AUTO-EDIT COMMANDS
 596 <  Expand context window     | k  Kill current line
 597 >  Contract context window   | y  Yank last killed line
 598 p  Move pointer to prev line | m  Merge current line into preceding line
 599 n  Move pointer to next line | o  Insert original line
 600 c  Print line context        | f  Flip current line and last edited line
 601 d  Print current saved lines |
 602 -----------------------------+-------------------------------------------
 603 s  Subtitute; replace ARG1 in current line with ARG2. If either ARG
 604    contains spaces, it must be single-quoted
 605 t  Commit changes and resume automated operations
 606 x  Dump record to exception file
 607 q  Quit
 608
 609 HELP
 610 return 0;
 611 }
 612
 613 sub quit { exit }
 614
 615 #-----------------------------------------------------------------------
 616
 617 =head2 initialize
 618
 619 Performs boring script initialization. Handles argument parsing,
 620 mostly.
 621
 622 =cut
 623
 624 sub initialize {
 625     my ($c) = @_;
 626     my @missing = ();
 627
 628     # set mode on existing filehandles
 629     binmode(STDIN, ':utf8');
 630
 631     my $rc = GetOptions( $c,
 632                          'autoscrub|a',
 633                          'fullauto',
 634                          'exception|x=s',
 635                          'output|o=s',
 636                          'marcfile|m=s',
 637                          'prefix|p=s',
 638                          'nocollapse|n',
 639                          'renumber-from|rf=i',
 640                          'renumber-tag|rt=i',
 641                          'renumber-subfield|rs=s',
 642                          'original-tag|ot=i',
 643                          'original-subfield|os=s',
 644                          'fix-subfield|fs=s',
 645                          'force-utf8',
 646                          'script',
 647                          'no-strip9',
 648                          'trashfile|t=s',
 649                          'trashhelp',
 650                          'help|h',
 651                        );
 652     show_help() unless $rc;
 653     show_help() if ($c->{help});
 654     show_trashhelp() if ($c->{trashhelp});
 655
 656     # defaults
 657     my $pfx = defined($c->{prefix}) ? $c->{prefix} : "bibs";
 658     $c->{ricount} = 0;
 659     $c->{rocount} = 0;
 660     $c->{'renumber-tag'} = 903 unless defined $c->{'renumber-tag'};
 661     $c->{'renumber-subfield'} = 'a' unless defined $c->{'renumber-subfield'};
 662     $c->{window} = 9;
 663     if ($c->{prefix}) {
 664         $c->{output} = join('.',$c->{prefix},'clean','marc','xml')
 665           unless $c->{output};
 666         $c->{exception} = join('.',$c->{prefix},'exception','marc','xml')
 667           unless $c->{exception};
 668         $c->{marcfile} = $c->{prefix} . '.marc.xml'
 669           unless $c->{marcfile};
 670     }
 671     show_help() unless ($c->{marcfile} and $c->{output});
 672
 673     if ($c->{trashfile}) {
 674         $c->{trash} = Equinox::Migration::SimpleTagList->new(file => $c->{trashfile})
 675     } else {
 676         $c->{trash} = Equinox::Migration::SimpleTagList->new;
 677     }
 678     # autotrash 901, 903 unless no strip-nines
 679     unless ($c->{'no-strip9'}) {
 680         $c->{trash}->add_tag(901);
 681         $c->{trash}->add_tag(903);
 682     }
 683     # remove original id sequence tag from trash hash if we know it
 684     $c->{trash}->remove_tag($c->{'original-tag'})
 685       if ( $c->{'original-tag'} and $c->{trash}->has($c->{'original-tag'}) );
 686 }
 687
 688 sub show_help {
 689     print <<HELP;
 690 Usage is: marc_cleanup [OPTIONS] <filelist>
 691 Options
 692   --output     -o  Cleaned MARCXML output filename
 693   --exception  -x  Exception (dumped records) MARCXML filename
 694        or
 695   --prefix=<PREFIX>    -p  Shared prefix for output/exception files. Will produce
 696                            PREFIX.clean.marc.xml and PREFIX.exception.marc.xml
 697
 698   --marcfile  -m  Input filename. Defaults to PREFIX.marc.xml
 699
 700   --renumber-from     -rf  Begin renumbering id sequence with this number
 701   --renumber-tag      -rt  Tag to use in renumbering (default: 903)
 702   --renumber-subfield -rs  Subfield code to use in renumbering (default: a)
 703   --original-tag      -ot  Original id tag; will be kept in output even if
 704                            it appears in the trash file
 705   --original-subfield -os  Original id subfield code. If this is specified
 706                            and renumbering is in effect, an old-to-new mapping
 707                            file (old2new.map) will be generated.
 708
 709   --force-utf8             Rewrite each record so that they describe themselves as
 710                            UTF-8 encoded
 711   --autoscrub         -a   Automatically remove non-numeric tags in data
 712   --fix-subfield      -fs  Subfield code to use in place of non-alphanumeric
 713                            or empty subfield codes
 714   --nocollapse        -n   Don't compress records to one line on output
 715   --no-strip9              Don't autoremove 901/903 tags in data
 716   --trashfile         -t   File containing trash tag data (see --trashhelp)
 717
 718   --fullauto               No manual edits. All problematic records dumped to
 719                            exception file.
 720
 721 HELP
 722 exit;
 723 }
 724
 725 sub show_trashhelp {
 726     print <<HELP;
 727 See
 728
 729 http://intra.lan.hq.esilibrary.com/dokuwiki/doku.php?id=migration:tag_files
 730
 731 for tag file syntax information.
 732 HELP
 733 exit;
 734 }