/[webpac2]/trunk/lib/WebPAC/Input.pm
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/lib/WebPAC/Input.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 585 by dpavlin, Wed Jul 5 19:52:45 2006 UTC revision 626 by dpavlin, Mon Sep 4 16:15:07 2006 UTC
# Line 7  use blib; Line 7  use blib;
7    
8  use WebPAC::Common;  use WebPAC::Common;
9  use base qw/WebPAC::Common/;  use base qw/WebPAC::Common/;
 use Text::Iconv;  
10  use Data::Dumper;  use Data::Dumper;
11    use Encode qw/from_to/;
12    
13  =head1 NAME  =head1 NAME
14    
# Line 16  WebPAC::Input - read different file form Line 16  WebPAC::Input - read different file form
16    
17  =head1 VERSION  =head1 VERSION
18    
19  Version 0.07  Version 0.11
20    
21  =cut  =cut
22    
23  our $VERSION = '0.07';  our $VERSION = '0.11';
24    
25  =head1 SYNOPSIS  =head1 SYNOPSIS
26    
# Line 39  C<fetch_rec> and optional C<init> functi Line 39  C<fetch_rec> and optional C<init> functi
39    
40  Perhaps a little code snippet.  Perhaps a little code snippet.
41    
42      use WebPAC::Input;          use WebPAC::Input;
43    
44      my $db = WebPAC::Input->new(          my $db = WebPAC::Input->new(
45          module => 'WebPAC::Input::ISIS',                  module => 'WebPAC::Input::ISIS',
                 config => $config,  
46                  low_mem => 1,                  low_mem => 1,
47      );          );
48    
49      $db->open('/path/to/database');          $db->open( path => '/path/to/database' );
50          print "database size: ",$db->size,"\n";          print "database size: ",$db->size,"\n";
51          while (my $rec = $db->fetch) {          while (my $rec = $db->fetch) {
52                  # do something with $rec                  # do something with $rec
# Line 69  Create new input database object. Line 68  Create new input database object.
68          no_progress_bar => 1,          no_progress_bar => 1,
69    );    );
70    
71  C<module> is low-level file format module. See L<WebPAC::Input::Isis> and  C<module> is low-level file format module. See L<WebPAC::Input::ISIS> and
72  L<WebPAC::Input::MARC>.  L<WebPAC::Input::MARC>.
73    
74  Optional parametar C<encoding> specify application code page (which will be  Optional parametar C<encoding> specify application code page (which will be
# Line 160  This function will read whole database i Line 159  This function will read whole database i
159    
160   $input->open(   $input->open(
161          path => '/path/to/database/file',          path => '/path/to/database/file',
162          code_page => '852',          code_page => 'cp852',
163          limit => 500,          limit => 500,
164          offset => 6000,          offset => 6000,
165          lookup => $lookup_obj,          lookup => $lookup_obj,
# Line 169  This function will read whole database i Line 168  This function will read whole database i
168                  my ($k,$v) = @_;                  my ($k,$v) = @_;
169                  # store lookup $k => $v                  # store lookup $k => $v
170          },          },
171            modify_records => {
172                    900 => { '^a' => { ' : ' => '^b' } },
173                    901 => { '*' => { '^b' => ' ; ' } },
174            },
175   );   );
176    
177  By default, C<code_page> is assumed to be C<852>.  By default, C<code_page> is assumed to be C<cp852>.
178    
179  C<offset> is optional parametar to position at some offset before reading from database.  C<offset> is optional parametar to position at some offset before reading from database.
180    
# Line 179  C<limit> is optional parametar to read j Line 182  C<limit> is optional parametar to read j
182    
183  C<stats> create optional report about usage of fields and subfields  C<stats> create optional report about usage of fields and subfields
184    
185  C<lookup_coderef> is closure to call when adding key => $value combinations to  C<lookup_coderef> is closure to call when adding C<< key => 'value' >> combinations to
186  lookup.  lookup.
187    
188    C<modify_records> specify mapping from subfields to delimiters or from
189    delimiters to subfields, as well as oprations on fields (if subfield is
190    defined as C<*>.
191    
192  Returns size of database, regardless of C<offset> and C<limit>  Returns size of database, regardless of C<offset> and C<limit>
193  parametars, see also C<size>.  parametars, see also C<size>.
194    
# Line 198  sub open { Line 205  sub open {
205                  if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');                  if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');
206    
207          $log->logcroak("need path") if (! $arg->{'path'});          $log->logcroak("need path") if (! $arg->{'path'});
208          my $code_page = $arg->{'code_page'} || '852';          my $code_page = $arg->{'code_page'} || 'cp852';
209    
210          # store data in object          # store data in object
211          $self->{'input_code_page'} = $code_page;          $self->{'input_code_page'} = $code_page;
# Line 206  sub open { Line 213  sub open {
213                  $self->{$v} = $arg->{$v} if ($arg->{$v});                  $self->{$v} = $arg->{$v} if ($arg->{$v});
214          }          }
215    
         # create Text::Iconv object  
         $self->{iconv} = Text::Iconv->new($code_page,$self->{'encoding'});      ## FIXME remove!  
   
216          my $filter_ref;          my $filter_ref;
217            my $recode_regex;
218            my $recode_map;
219    
220          if ($self->{recode}) {          if ($self->{recode}) {
221                  my @r = split(/\s/, $self->{recode});                  my @r = split(/\s/, $self->{recode});
222                  if ($#r % 2 != 1) {                  if ($#r % 2 != 1) {
223                          $log->logwarn("recode needs even number of elements (some number of valid pairs)");                          $log->logwarn("recode needs even number of elements (some number of valid pairs)");
224                  } else {                  } else {
                         my $recode;  
225                          while (@r) {                          while (@r) {
226                                  my $from = shift @r;                                  my $from = shift @r;
227                                  my $to = shift @r;                                  my $to = shift @r;
228                                  $recode->{$from} = $to;                                  $recode_map->{$from} = $to;
229                          }                          }
230    
231                          my $regex = join '|' => keys %{ $recode };                          $recode_regex = join '|' => keys %{ $recode_map };
   
                         $log->debug("using recode regex: $regex");  
                           
                         $filter_ref = sub {  
                                 my $t = shift;  
                                 $t =~ s/($regex)/$recode->{$1}/g;  
                                 return $t;  
                         };  
232    
233                            $log->debug("using recode regex: $recode_regex");
234                  }                  }
235    
236          }          }
237    
238            my $rec_regex = $self->modify_record_regexps(%{ $arg->{modify_records} });
239            $log->debug("rec_regex: ", Dumper($rec_regex));
240    
241          my ($db, $size) = $self->{open_db}->( $self,          my ($db, $size) = $self->{open_db}->( $self,
242                  path => $arg->{path},                  path => $arg->{path},
243                  filter => $filter_ref,  #               filter => sub {
244    #                       my ($l,$f_nr) = @_;
245    #                       return unless defined($l);
246    #                       from_to($l, $code_page, $self->{'encoding'});
247    #                       $l =~ s/($recode_regex)/$recode_map->{$1}/g if ($recode_regex && $recode_map);
248    #                       return $l;
249    #               },
250                  %{ $arg },                  %{ $arg },
251          );          );
252    
# Line 279  sub open { Line 286  sub open {
286    
287                  $log->debug("position: $pos\n");                  $log->debug("position: $pos\n");
288    
289                  my $rec = $self->{fetch_rec}->($self, $db, $pos );                  my $rec = $self->{fetch_rec}->($self, $db, $pos, sub {
290                                    my ($l,$f_nr) = @_;
291    #                               return unless defined($l);
292    #                               return $l unless ($rec_regex && $f_nr);
293    
294                                    $log->debug("-=> $f_nr ## $l");
295    
296                                    # codepage conversion and recode_regex
297                                    from_to($l, $code_page, $self->{'encoding'});
298                                    $l =~ s/($recode_regex)/$recode_map->{$1}/g if ($recode_regex && $recode_map);
299    
300                                    # apply regexps
301                                    if ($rec_regex && defined($rec_regex->{$f_nr})) {
302                                            $log->logconfess("regexps->{$f_nr} must be ARRAY") if (ref($rec_regex->{$f_nr}) ne 'ARRAY');
303                                            my $c = 0;
304                                            foreach my $r (@{ $rec_regex->{$f_nr} }) {
305                                                    my $old_l = $l;
306                                                    eval '$l =~ ' . $r;
307                                                    if ($old_l ne $l) {
308                                                            $log->debug("REGEX on $f_nr eval \$l =~ $r\n## old l: [$old_l]\n## new l: [$l]");
309                                                    }
310                                                    $log->error("error applying regex: $r") if ($@);
311                                            }
312                                    }
313    
314                                    $log->debug("<=- $f_nr ## $l");
315                                    return $l;
316                    });
317    
318                  $log->debug(sub { Dumper($rec) });                  $log->debug(sub { Dumper($rec) });
319    
# Line 300  sub open { Line 334  sub open {
334    
335                  # update counters for statistics                  # update counters for statistics
336                  if ($self->{stats}) {                  if ($self->{stats}) {
337                          map {  
338                                  my $fld = $_;                          # fetch clean record with regexpes applied for statistics
339                            my $rec = $self->{fetch_rec}->($self, $db, $pos);
340    
341                            foreach my $fld (keys %{ $rec }) {
342                                  $self->{_stats}->{fld}->{ $fld }++;                                  $self->{_stats}->{fld}->{ $fld }++;
343                                  if (ref($rec->{ $fld }) eq 'ARRAY') {  
344                                          map {                                  $log->logdie("invalid record fild $fld, not ARRAY")
345                                                  if (ref($_) eq 'HASH') {                                          unless (ref($rec->{ $fld }) eq 'ARRAY');
346                                                          map {          
347                                                                  $self->{_stats}->{sf}->{ $fld }->{ $_ }++;                                  foreach my $row (@{ $rec->{$fld} }) {
348                                                          } keys %{ $_ };  
349                                                  } else {                                          if (ref($row) eq 'HASH') {
350                                                          $self->{_stats}->{repeatable}->{ $fld }++;  
351                                                    foreach my $sf (keys %{ $row }) {
352                                                            next if ($sf eq 'subfields');
353                                                            $self->{_stats}->{sf}->{ $fld }->{ $sf }->{count}++;
354                                                            $self->{_stats}->{sf}->{ $fld }->{ $sf }->{repeatable}++
355                                                                            if (ref($row->{$sf}) eq 'ARRAY');
356                                                  }                                                  }
357                                          } @{ $rec->{$fld} };  
358                                            } else {
359                                                    $self->{_stats}->{repeatable}->{ $fld }++;
360                                            }
361                                  }                                  }
362                          } keys %{ $rec };                          }
363                  }                  }
364    
365                  $self->progress_bar($pos,$to_rec) unless ($self->{no_progress_bar});                  $self->progress_bar($pos,$to_rec) unless ($self->{no_progress_bar});
# Line 469  sub stats { Line 514  sub stats {
514    
515                          if (defined($s->{sf}->{$f})) {                          if (defined($s->{sf}->{$f})) {
516                                  map {                                  map {
517                                          $o .= sprintf(" %s:%d", $_, $s->{sf}->{$f}->{$_});                                          $o .= sprintf(" %s:%d%s", $_,
518                                                    $s->{sf}->{$f}->{$_}->{count},
519                                                    $s->{sf}->{$f}->{$_}->{repeatable} ? '*' : '',
520                                            );
521                                  } sort keys %{ $s->{sf}->{$f} };                                  } sort keys %{ $s->{sf}->{$f} };
522                          }                          }
523    
# Line 486  sub stats { Line 534  sub stats {
534          return $out;          return $out;
535  }  }
536    
537    =head2 modify_record_regexps
538    
539    Generate hash with regexpes to be applied using L<filter>.
540    
541      my $regexpes = $input->modify_record_regexps(
542                    900 => { '^a' => { ' : ' => '^b' } },
543                    901 => { '*' => { '^b' => ' ; ' } },
544      );
545    
546    =cut
547    
548    sub modify_record_regexps {
549            my $self = shift;
550            my $modify_record = {@_};
551    
552            my $regexpes;
553    
554            foreach my $f (keys %$modify_record) {
555    warn "--- f: $f\n";
556                    foreach my $sf (keys %{ $modify_record->{$f} }) {
557    warn "---- sf: $sf\n";
558                            foreach my $from (keys %{ $modify_record->{$f}->{$sf} }) {
559                                    my $to = $modify_record->{$f}->{$sf}->{$from};
560                                    #die "no field?" unless defined($to);
561    warn "----- transform: |$from| -> |$to|\n";
562    
563                                    if ($sf =~ /^\^/) {
564                                            my $regex =
565                                                    's/\Q'. $sf .'\E([^\^]+)\Q'. $from .'\E([^\^]+)/'. $sf .'$1'. $to .'$2/g';
566                                            push @{ $regexpes->{$f} }, $regex;
567    warn ">>>>> $regex [sf]\n";
568                                    } else {
569                                            my $regex =
570                                                    's/\Q'. $from .'\E/'. $to .'/g';
571                                            push @{ $regexpes->{$f} }, $regex;
572    warn ">>>>> $regex [global]\n";
573                                    }
574    
575                            }
576                    }
577            }
578    
579            return $regexpes;
580    }
581    
582  =head1 MEMORY USAGE  =head1 MEMORY USAGE
583    
584  C<low_mem> options is double-edged sword. If enabled, WebPAC  C<low_mem> options is double-edged sword. If enabled, WebPAC
# Line 523  Dobrica Pavlinusic, C<< <dpavlin@rot13.o Line 616  Dobrica Pavlinusic, C<< <dpavlin@rot13.o
616    
617  =head1 COPYRIGHT & LICENSE  =head1 COPYRIGHT & LICENSE
618    
619  Copyright 2005 Dobrica Pavlinusic, All Rights Reserved.  Copyright 2005-2006 Dobrica Pavlinusic, All Rights Reserved.
620    
621  This program is free software; you can redistribute it and/or modify it  This program is free software; you can redistribute it and/or modify it
622  under the same terms as Perl itself.  under the same terms as Perl itself.
Legend:
Removed from v.585  
changed lines
  Added in v.626
  ViewVC Help
Powered by ViewVC 1.1.26