/[webpac2]/trunk/lib/WebPAC/Normalize.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/Normalize.pm

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

revision 15 by dpavlin, Sun Jul 17 10:42:23 2005 UTC revision 368 by dpavlin, Sun Jan 8 20:32:06 2006 UTC
# Line 2  package WebPAC::Normalize; Line 2  package WebPAC::Normalize;
2    
3  use warnings;  use warnings;
4  use strict;  use strict;
5    use blib;
6    use WebPAC::Common;
7    use base 'WebPAC::Common';
8  use Data::Dumper;  use Data::Dumper;
 use Storable;  
9    
10  =head1 NAME  =head1 NAME
11    
# Line 11  WebPAC::Normalize - data mungling for no Line 13  WebPAC::Normalize - data mungling for no
13    
14  =head1 VERSION  =head1 VERSION
15    
16  Version 0.01  Version 0.08
17    
18  =cut  =cut
19    
20  our $VERSION = '0.01';  our $VERSION = '0.08';
21    
22  =head1 SYNOPSIS  =head1 SYNOPSIS
23    
# Line 47  optional C<filter{filter_name}> at B<beg Line 49  optional C<filter{filter_name}> at B<beg
49  code defined as code ref on format after field substitution to producing  code defined as code ref on format after field substitution to producing
50  output  output
51    
52    There is one built-in filter called C<regex> which can be use like this:
53    
54      filter{regex(s/foo/bar/)}
55    
56  =item *  =item *
57    
58  optional C<lookup{...}> will be then performed. See C<WebPAC::Lookups>.  optional C<lookup{...}> will be then performed. See C<WebPAC::Lookups>.
# Line 79  Create new normalisation object Line 85  Create new normalisation object
85                          return length($_);                          return length($_);
86                  }, ...                  }, ...
87          },          },
88          cache_data_structure => './cache/ds/',          db => $db_obj,
89          lookup_regex => $lookup->regex,          lookup_regex => $lookup->regex,
90            lookup => $lookup_obj,
91            prefix => 'foobar',
92    );    );
93    
94  Parametar C<filter> defines user supplied snippets of perl code which can  Parametar C<filter> defines user supplied snippets of perl code which can
95  be use with C<filter{...}> notation.  be use with C<filter{...}> notation.
96    
97  Optional parameter C<cache_data_structure> defines path to directory  C<prefix> is used to form filename for database record (to support multiple
98  in which cache file for C<data_structure> call will be created.  source files which are joined in one database).
99    
100  Recommended parametar C<lookup_regex> is used to enable parsing of lookups  Recommended parametar C<lookup_regex> is used to enable parsing of lookups
101  in structures.  in structures. If you pass this parametar, you must also pass C<lookup>
102    which is C<WebPAC::Lookup> object.
103    
104  =cut  =cut
105    
# Line 99  sub new { Line 108  sub new {
108          my $self = {@_};          my $self = {@_};
109          bless($self, $class);          bless($self, $class);
110    
111          $self->setup_cache_dir( $self->{'cache_data_structure'} );          my $r = $self->{'lookup_regex'} ? 1 : 0;
112            my $l = $self->{'lookup'} ? 1 : 0;
         $self ? return $self : return undef;  
 }  
   
 =head2 setup_cache_dir  
   
 Check if specified cache directory exist, and if not, disable caching.  
   
  $setup_cache_dir('./cache/ds/');  
113    
114  If you pass false or zero value to this function, it will disable          my $log = $self->_get_logger();
 cacheing.  
   
 =cut  
115    
116  sub setup_cache_dir {          # those two must be in pair
117          my $self = shift;          if ( ($r & $l) != ($r || $l) ) {
118                    my $log = $self->_get_logger();
119                    $log->logdie("lookup_regex and lookup must be in pair");
120            }
121    
122          my $dir = shift;          $log->logdie("lookup must be WebPAC::Lookup object") if ($self->{'lookup'} && ! $self->{'lookup'}->isa('WebPAC::Lookup'));
123    
124          my $log = $self->_get_logger();          $log->warn("no prefix defined. please check that!") unless ($self->{'prefix'});
125    
126          if ($dir) {          $log->debug("using lookup regex: ", $self->{lookup_regex}) if ($r && $l);
                 my $msg;  
                 if (! -e $dir) {  
                         $msg = "doesn't exist";  
                 } elsif (! -d $dir) {  
                         $msg = "is not directory";  
                 } elsif (! -w $dir) {  
                         $msg = "not writable";  
                 }  
127    
128                  if ($msg) {          if (! $self->{filter} || ! $self->{filter}->{regex}) {
129                          undef $self->{'cache_data_structure'};                  $log->debug("adding built-in filter regex");
130                          $log->warn("cache_data_structure $dir $msg, disabling...");                  $self->{filter}->{regex} = sub {
131                  } else {                          my ($val, $regex) = @_;
132                          $log->debug("using cache dir $dir");                          eval "\$val =~ $regex";
133                  }                          return $val;
134          } else {                  };
                 $log->debug("disabling cache");  
                 undef $self->{'cache_data_structure'};  
135          }          }
136    
137            $self ? return $self : return undef;
138  }  }
139    
140    
# Line 152  C<conf/normalize/*.xml>. Line 145  C<conf/normalize/*.xml>.
145    
146  This structures are used to produce output.  This structures are used to produce output.
147    
148   my @ds = $webpac->data_structure($rec);   my $ds = $webpac->data_structure($rec);
   
 B<Note: historical oddity follows>  
   
 This method will also set C<< $webpac->{'currnet_filename'} >> if there is  
 C<< <filename> >> tag and C<< $webpac->{'headline'} >> if there is  
 C<< <headline> >> tag.  
149    
150  =cut  =cut
151    
# Line 170  sub data_structure { Line 157  sub data_structure {
157          my $rec = shift;          my $rec = shift;
158          $log->logconfess("need HASH as first argument!") if ($rec !~ /HASH/o);          $log->logconfess("need HASH as first argument!") if ($rec !~ /HASH/o);
159    
160            $log->debug("data_structure rec = ", sub { Dumper($rec) });
161    
162            $log->logdie("need unique ID (mfn) in field 000 of record " . Dumper($rec) ) unless (defined($rec->{'000'}));
163    
164            my $id = $rec->{'000'}->[0] || $log->logdie("field 000 isn't array!");
165    
166          my $cache_file;          my $cache_file;
167    
168          if (my $cache_path = $self->{'cache_data_structure'}) {          if ($self->{'db'}) {
169                  my $id = $rec->{'000'};                  my $ds = $self->{'db'}->load_ds( id => $id, prefix => $self->{prefix} );
170                  $id = $rec->{'000'}->[0] if ($id =~ m/^ARRAY/o);                  $log->debug("load_ds( rec = ", sub { Dumper($rec) }, ") = ", sub { Dumper($ds) });
171                  unless (defined($id)) {                  return $ds if ($ds);
172                          $log->warn("Can't use cache_data_structure on records without unique identifier in field 000");                  $log->debug("cache miss, creating");
                         undef $self->{'cache_data_structure'};  
                 } else {  
                         $cache_file = "$cache_path/$id";  
                         if (-r $cache_file) {  
                                 my $ds_ref = retrieve($cache_file);  
                                 if ($ds_ref) {  
                                         $log->debug("cache hit: $cache_file");  
                                         my $ok = 1;  
                                         foreach my $f (qw(current_filename headline)) {  
                                                 if ($ds_ref->{$f}) {  
                                                         $self->{$f} = $ds_ref->{$f};  
                                                 } else {  
                                                         $ok = 0;  
                                                 }  
                                         };  
                                         if ($ok && $ds_ref->{'ds'}) {  
                                                 return @{ $ds_ref->{'ds'} };  
                                         } else {  
                                                 $log->warn("cache_data_structure $cache_path corrupt. Use rm $cache_path/* to re-create it on next run!");  
                                                 undef $self->{'cache_data_structure'};  
                                         }  
                                 }  
                         }  
                 }  
173          }          }
174    
         undef $self->{'currnet_filename'};  
         undef $self->{'headline'};  
   
175          my @sorted_tags;          my @sorted_tags;
176          if ($self->{tags_by_order}) {          if ($self->{tags_by_order}) {
177                  @sorted_tags = @{$self->{tags_by_order}};                  @sorted_tags = @{$self->{tags_by_order}};
# Line 214  sub data_structure { Line 180  sub data_structure {
180                  $self->{tags_by_order} = \@sorted_tags;                  $self->{tags_by_order} = \@sorted_tags;
181          }          }
182    
183          my @ds;          my $ds;
184    
185          $log->debug("tags: ",sub { join(", ",@sorted_tags) });          $log->debug("tags: ",sub { join(", ",@sorted_tags) });
186    
# Line 225  sub data_structure { Line 191  sub data_structure {
191  #print "field $field [",$self->{'tag'},"] = ",Dumper($self->{'import_xml'}->{'indexer'}->{$field}->{$self->{'tag'}});  #print "field $field [",$self->{'tag'},"] = ",Dumper($self->{'import_xml'}->{'indexer'}->{$field}->{$self->{'tag'}});
192    
193                  foreach my $tag (@{$self->{'import_xml'}->{'indexer'}->{$field}->{$self->{'tag'}}}) {                  foreach my $tag (@{$self->{'import_xml'}->{'indexer'}->{$field}->{$self->{'tag'}}}) {
194                          my $format = $tag->{'value'} || $tag->{'content'};                          my $format;
195    
196                          $log->debug("format: $format");                          $log->logdie("expected tag HASH and got $tag") unless (ref($tag) eq 'HASH');
197                            $format = $tag->{'value'} || $tag->{'content'};
198    
199                          my @v;                          my @v;
200                          if ($self->{'lookup_regex'} && $format =~ $self->{'lookup_regex'}) {                          if ($self->{'lookup_regex'} && $format =~ $self->{'lookup_regex'}) {
# Line 235  sub data_structure { Line 202  sub data_structure {
202                          } else {                          } else {
203                                  @v = $self->parse_to_arr($rec,$format);                                  @v = $self->parse_to_arr($rec,$format);
204                          }                          }
205                          next if (! @v);                          if (! @v) {
206                                    $log->debug("$field <",$self->{tag},"> format: $format no values");
207    #                               next;
208                            } else {
209                                    $log->debug("$field <",$self->{tag},"> format: $format values: ", join(",", @v));
210                            }
211    
212                          if ($tag->{'sort'}) {                          if ($tag->{'sort'}) {
213                                  @v = $self->sort_arr(@v);                                  @v = $self->sort_arr(@v);
# Line 246  sub data_structure { Line 218  sub data_structure {
218                                  @v = map { $self->apply_format($tag->{'format_name'},$tag->{'format_delimiter'},$_) } @v;                                  @v = map { $self->apply_format($tag->{'format_name'},$tag->{'format_delimiter'},$_) } @v;
219                          }                          }
220    
                         if ($field eq 'filename') {  
                                 $self->{'current_filename'} = join('',@v);  
                                 $log->debug("filename: ",$self->{'current_filename'});  
                         } elsif ($field eq 'headline') {  
                                 $self->{'headline'} .= join('',@v);  
                                 $log->debug("headline: ",$self->{'headline'});  
                                 next; # don't return headline in data_structure!  
                         }  
   
221                          # delimiter will join repeatable fields                          # delimiter will join repeatable fields
222                          if ($tag->{'delimiter'}) {                          if ($tag->{'delimiter'}) {
223                                  @v = ( join($tag->{'delimiter'}, @v) );                                  @v = ( join($tag->{'delimiter'}, @v) );
224                          }                          }
225    
226                          # default types                          # default types
227                          my @types = qw(display swish);                          my @types = qw(display search);
228                          # override by type attribute                          # override by type attribute
229                          @types = ( $tag->{'type'} ) if ($tag->{'type'});                          @types = ( $tag->{'type'} ) if ($tag->{'type'});
230    
231                          foreach my $type (@types) {                          foreach my $type (@types) {
232                                  # append to previous line?                                  # append to previous line?
233                                  $log->debug("type: $type ",sub { join(" ",@v) }, $row->{'append'} || 'no append');                                  $log->debug("tag $field / $type [",sub { join(",",@v) }, "] ", $row->{'append'} || 'no append');
234                                  if ($tag->{'append'}) {                                  if ($tag->{'append'}) {
235    
236                                          # I will delimit appended part with                                          # I will delimit appended part with
# Line 294  sub data_structure { Line 257  sub data_structure {
257    
258                          # TODO: name_sigular, name_plural                          # TODO: name_sigular, name_plural
259                          my $name = $self->{'import_xml'}->{'indexer'}->{$field}->{'name'};                          my $name = $self->{'import_xml'}->{'indexer'}->{$field}->{'name'};
260                          $row->{'name'} = $name ? $self->_x($name) : $field;                          my $row_name = $name ? $self->_x($name) : $field;
261    
262                          # post-sort all values in field                          # post-sort all values in field
263                          if ($self->{'import_xml'}->{'indexer'}->{$field}->{'sort'}) {                          if ($self->{'import_xml'}->{'indexer'}->{$field}->{'sort'}) {
264                                  $log->warn("sort at field tag not implemented");                                  $log->warn("sort at field tag not implemented");
265                          }                          }
266    
267                          push @ds, $row;                          $ds->{$row_name} = $row;
268    
269                          $log->debug("row $field: ",sub { Dumper($row) });                          $log->debug("row $field: ",sub { Dumper($row) });
270                  }                  }
271    
272          }          }
273    
274          if ($cache_file) {          $self->{'db'}->save_ds(
275                  store {                  id => $id,
276                          ds => \@ds,                  ds => $ds,
277                          current_filename => $self->{'current_filename'},                  prefix => $self->{prefix},
278                          headline => $self->{'headline'},          ) if ($self->{'db'});
                 }, $cache_file;  
                 $log->debug("created storable cache file $cache_file");  
         }  
279    
280          return @ds;          $log->debug("ds: ", sub { Dumper($ds) });
281    
282            $log->logconfess("data structure returned is not array any more!") if wantarray;
283    
284            return $ds;
285    
286  }  }
287    
# Line 329  return output or nothing depending on ev Line 293  return output or nothing depending on ev
293    
294   my $text = $webpac->parse($rec,'eval{"v901^a" eq "Deskriptor"}descriptor: v250^a', $i);   my $text = $webpac->parse($rec,'eval{"v901^a" eq "Deskriptor"}descriptor: v250^a', $i);
295    
296    Filters are implemented here. While simple form of filters looks like this:
297    
298      filter{name_of_filter}
299    
300    but, filters can also have variable number of parametars like this:
301    
302      filter{name_of_filter(param,param,param)}
303    
304  =cut  =cut
305    
306    my $warn_once;
307    
308  sub parse {  sub parse {
309          my $self = shift;          my $self = shift;
310    
# Line 348  sub parse { Line 322  sub parse {
322    
323          my @out;          my @out;
324    
325          $log->debug("format: $format");          $log->debug("format: $format [$i]");
326    
327          my $eval_code;          my $eval_code;
328          # remove eval{...} from beginning          # remove eval{...} from beginning
# Line 358  sub parse { Line 332  sub parse {
332          # remove filter{...} from beginning          # remove filter{...} from beginning
333          $filter_name = $1 if ($format =~ s/^filter{([^}]+)}//s);          $filter_name = $1 if ($format =~ s/^filter{([^}]+)}//s);
334    
335            # did we found any (att all) field from format in row?
336            my $found_any;
337            # prefix before first field which we preserve it $found_any
338          my $prefix;          my $prefix;
339          my $all_found=0;  
340            my $f_step = 1;
341    
342          while ($format =~ s/^(.*?)(v|s)(\d+)(?:\^(\w))?//s) {          while ($format =~ s/^(.*?)(v|s)(\d+)(?:\^(\w))?//s) {
343    
344                  my $del = $1 || '';                  my $del = $1 || '';
345                  $prefix ||= $del if ($all_found == 0);                  $prefix = $del if ($f_step == 1);
346    
347                    my $fld_type = lc($2);
348    
349                  # repeatable index                  # repeatable index
350                  my $r = $i;                  my $r = $i;
351                  $r = 0 if (lc("$2") eq 's');                  if ($fld_type eq 's') {
352                            if ($found_any->{'v'}) {
353                                    $r = 0;
354                            } else {
355                                    return;
356                            }
357                    }
358    
359                  my $found = 0;                  my $found = 0;
360                  my $tmp = $self->get_data(\$rec,$3,$4,$r,\$found);                  my $tmp = $self->get_data(\$rec,$3,$4,$r,\$found);
361    
362                  if ($found) {                  if ($found) {
363                          push @out, $del;                          $found_any->{$fld_type} += $found;
364    
365                            # we will skip delimiter before first occurence of field!
366                            push @out, $del unless($found_any->{$fld_type} == 1);
367                          push @out, $tmp;                          push @out, $tmp;
                         $all_found += $found;  
368                  }                  }
369                    $f_step++;
370          }          }
371    
372          return if (! $all_found);          # test if any fields found?
373            return if (! $found_any->{'v'} && ! $found_any->{'s'});
374    
375          my $out = join('',@out);          my $out = join('',@out);
376    
# Line 400  sub parse { Line 390  sub parse {
390                  return if (! $self->_eval($eval));                  return if (! $self->_eval($eval));
391          }          }
392                    
393          if ($filter_name && $self->{'filter'}->{$filter_name}) {          if ($filter_name) {
394                  $log->debug("about to filter{$filter_name} format: $out");                  my @filter_args;
395                  $out = $self->{'filter'}->{$filter_name}->($out);                  if ($filter_name =~ s/(\w+)\((.*)\)/$1/) {
396                  return unless(defined($out));                          @filter_args = split(/,/, $2);
397                  $log->debug("filter result: $out");                  }
398                    if ($self->{'filter'}->{$filter_name}) {
399                            $log->debug("about to filter{$filter_name} format: $out with arguments: ", join(",", @filter_args));
400                            unshift @filter_args, $out;
401                            $out = $self->{'filter'}->{$filter_name}->(@filter_args);
402                            return unless(defined($out));
403                            $log->debug("filter result: $out");
404                    } elsif (! $warn_once->{$filter_name}) {
405                            $log->warn("trying to use undefined filter $filter_name");
406                            $warn_once->{$filter_name}++;
407                    }
408          }          }
409    
410          return $out;          return $out;
# Line 484  sub fill_in { Line 484  sub fill_in {
484          }          }
485    
486          my $found = 0;          my $found = 0;
487            my $just_single = 1;
488    
489          my $eval_code;          my $eval_code;
490          # remove eval{...} from beginning          # remove eval{...} from beginning
# Line 495  sub fill_in { Line 496  sub fill_in {
496    
497          # do actual replacement of placeholders          # do actual replacement of placeholders
498          # repeatable fields          # repeatable fields
499          $format =~ s/v(\d+)(?:\^(\w))?/$self->get_data(\$rec,$1,$2,$i,\$found)/ges;          if ($format =~ s/v(\d+)(?:\^(\w))?/$self->get_data(\$rec,$1,$2,$i,\$found)/ges) {
500                    $just_single = 0;
501            }
502    
503          # non-repeatable fields          # non-repeatable fields
504          $format =~ s/s(\d+)(?:\^(\w))?/$self->get_data(\$rec,$1,$2,0,\$found)/ges;          if ($format =~ s/s(\d+)(?:\^(\w))?/$self->get_data(\$rec,$1,$2,0,\$found)/ges) {
505                    return if ($i > 0 && $just_single);
506            }
507    
508          if ($found) {          if ($found) {
509                  $log->debug("format: $format");                  $log->debug("format: $format");
# Line 513  sub fill_in { Line 519  sub fill_in {
519                  }                  }
520                  # do we have lookups?                  # do we have lookups?
521                  if ($self->{'lookup'}) {                  if ($self->{'lookup'}) {
522                          return $self->lookup($format);                          if ($self->{'lookup'}->can('lookup')) {
523                                    my @lookup = $self->{lookup}->lookup($format);
524                                    $log->debug("lookup $format", join(", ", @lookup));
525                                    return @lookup;
526                            } else {
527                                    $log->warn("Have lookup object but can't invoke lookup method");
528                            }
529                  } else {                  } else {
530                          return $format;                          return $format;
531                  }                  }
# Line 546  sub fill_in_to_arr { Line 558  sub fill_in_to_arr {
558          my $i = 0;          my $i = 0;
559          my @arr;          my @arr;
560    
561          while (my @v = $self->fill_in($rec,$format_utf8,$i++)) {          while (my $v = $self->fill_in($rec,$format_utf8,$i++)) {
562                  push @arr, @v;                  push @arr, $v;
563          }          }
564    
565          $log->debug("format '$format_utf8' returned ",--$i," elements: ", sub { join(" | ",@arr) }) if (@arr);          $log->debug("format '$format_utf8' returned ",--$i," elements: ", sub { join(" | ",@arr) }) if (@arr);
# Line 560  sub fill_in_to_arr { Line 572  sub fill_in_to_arr {
572    
573  Returns value from record.  Returns value from record.
574    
575   my $text = $self->get_data(\$rec,$f,$sf,$i,\$found);   my $text = $self->get_data(\$rec,$f,$sf,$i,\$found,\$fld_occurances);
576    
577    Required arguments are:
578    
579    =over 8
580    
581  Arguments are:  =item C<$rec>
 record reference C<$rec>,  
 field C<$f>,  
 optional subfiled C<$sf>,  
 index for repeatable values C<$i>.  
582    
583  Optinal variable C<$found> will be incremeted if there  record reference
 is field.  
584    
585  Returns value or empty string.  =item C<$f>
586    
587    field
588    
589    =item C<$sf>
590    
591    optional subfield
592    
593    =item C<$i>
594    
595    index offset for repeatable values ( 0 ... $#occurances )
596    
597    =item C<$found>
598    
599    optional variable that will be incremeted if preset
600    
601    =item C<$fld_occurances>
602    
603    hash to hold maximum occurances of C<field\tsubfield> combinations
604    (which can be accessed using keys in same format)
605    
606    =back
607    
608    Returns value or empty string, updates C<$found> and C<fld_occurences>
609    if present.
610    
611  =cut  =cut
612    
613  sub get_data {  sub get_data {
614          my $self = shift;          my $self = shift;
615    
616          my ($rec,$f,$sf,$i,$found) = @_;          my ($rec,$f,$sf,$i,$found,$cache) = @_;
617    
618            return '' unless ($$rec->{$f} && ref($$rec->{$f}) eq 'ARRAY');
619    
620            if (defined($$cache)) {
621                    $$cache->{"$f\t$sf"} ||= $$#rec->{$f};
622            }
623    
624          if ($$rec->{$f}) {          return '' unless ($$rec->{$f}->[$i]);
625                  return '' if (! $$rec->{$f}->[$i]);  
626            {
627                  no strict 'refs';                  no strict 'refs';
628                  if ($sf && $$rec->{$f}->[$i]->{$sf}) {                  if (defined($sf)) {
629                          $$found++ if (defined($$found));                          $$found++ if (defined($$found) && $$rec->{$f}->[$i]->{$sf});
630                          return $$rec->{$f}->[$i]->{$sf};                          return $$rec->{$f}->[$i]->{$sf};
631                  } elsif ($$rec->{$f}->[$i]) {                  } else {
632                          $$found++ if (defined($$found));                          $$found++ if (defined($$found));
633                          # it still might have subfield, just                          # it still might have subfields, just
634                          # not specified, so we'll dump all                          # not specified, so we'll dump some debug info
635                          if ($$rec->{$f}->[$i] =~ /HASH/o) {                          if ($$rec->{$f}->[$i] =~ /HASH/o) {
636                                  my $out;                                  my $out;
637                                  foreach my $k (keys %{$$rec->{$f}->[$i]}) {                                  foreach my $k (keys %{$$rec->{$f}->[$i]}) {
638                                          $out .= $$rec->{$f}->[$i]->{$k}." ";                                          $out .= '$' . $k .':' . $$rec->{$f}->[$i]->{$k}." ";
639                                  }                                  }
640                                  return $out;                                  return $out;
641                          } else {                          } else {
642                                  return $$rec->{$f}->[$i];                                  return $$rec->{$f}->[$i];
643                          }                          }
644                  }                  }
         } else {  
                 return '';  
645          }          }
646  }  }
647    
# Line 639  sub apply_format { Line 679  sub apply_format {
679          $log->debug("using format $name [$format] on $data to produce: $out");          $log->debug("using format $name [$format] on $data to produce: $out");
680    
681          if ($self->{'lookup_regex'} && $out =~ $self->{'lookup_regex'}) {          if ($self->{'lookup_regex'} && $out =~ $self->{'lookup_regex'}) {
682                  return $self->lookup($out);                  return $self->{'lookup'}->lookup($out);
683          } else {          } else {
684                  return $out;                  return $out;
685          }          }
# Line 722  under the same terms as Perl itself. Line 762  under the same terms as Perl itself.
762    
763  =cut  =cut
764    
765  1; # End of WebPAC::DB  1; # End of WebPAC::Normalize

Legend:
Removed from v.15  
changed lines
  Added in v.368

  ViewVC Help
Powered by ViewVC 1.1.26