git.rot13.org Git - webpac2/blob - lib/WebPAC/Output/KinoSearch.pm

   1 package WebPAC::Output::KinoSearch;
   2
   3 use warnings;
   4 use strict;
   5
   6 use base qw/WebPAC::Common/;
   7
   8 use KinoSearch::InvIndexer;
   9 use KinoSearch::Analysis::PolyAnalyzer;
  10 use Encode qw/from_to/;
  11 use Data::Dumper;
  12
  13 =head1 NAME
  14
  15 WebPAC::Output::KinoSearch - Create KinoSearch full text index
  16
  17 =head1 VERSION
  18
  19 Version 0.01
  20
  21 =cut
  22
  23 our $VERSION = '0.01';
  24
  25 =head1 SYNOPSIS
  26
  27 Create full text index using KinoSearch index from data with
  28 type C<search>.
  29
  30 =head1 FUNCTIONS
  31
  32 =head2 new
  33
  34 Open KinoSearch index
  35
  36  my $est = new WebPAC::Output::KinoSearch(
  37         index_path => '/path/to/invindex',
  38         fields => qw/name of all filelds used/,
  39         database => 'demo',
  40         label => 'node label',
  41         encoding => 'iso-8859-2',
  42         clean => 1,
  43  );
  44
  45 Options are:
  46
  47 =over 4
  48
  49 =item index_path
  50
  51 path to KinoSearch index to use
  52
  53 =item fields
  54
  55 name of all fields used in this index
  56
  57 =item database
  58
  59 name of database from which data comes
  60
  61 =item label
  62
  63 label for node (optional)
  64
  65 =item encoding
  66
  67 character encoding of C<data_structure> if it's differenet than C<ISO-8859-2>
  68 (and it probably is). This encoding will be converted to C<UTF-8> for
  69 index.
  70
  71 =back
  72
  73 =cut
  74
  75 sub new {
  76         my $class = shift;
  77         my $self = {@_};
  78         bless($self, $class);
  79
  80         my $log = $self->_get_logger;
  81
  82         #$log->debug("self: ", sub { Dumper($self) });
  83
  84         foreach my $p (qw/index_path fields database/) {
  85                 $log->logdie("need $p") unless ($self->{$p});
  86         }
  87
  88         $log->logdie("fields is not ARRAY") unless (ref($self->{fields}) eq 'ARRAY');
  89
  90         $self->{encoding} ||= 'ISO-8859-2';
  91
  92         $log->info("using index $self->{index_path} with encoding $self->{encoding}");
  93
  94         my $analyzer = KinoSearch::Analysis::PolyAnalyzer->new( language => 'en' );
  95
  96         $self->{invindex} = KinoSearch::InvIndexer->new(
  97                 invindex => $self->{index_path},
  98                 create   => $self->{clean},
  99                 analyzer => $analyzer,
 100         );
 101
 102         foreach my $f (@{ $self->{fields} }) {
 103                 $self->{invindex}->spec_field(
 104                         name  => $f,
 105 #                       boost => 10,
 106                         stored => 1,
 107                         indexed => 1,
 108                         vectorized => 0,
 109                 );
 110         }
 111
 112         $self ? return $self : return undef;
 113 }
 114
 115
 116 =head2 add
 117
 118 Adds one entry to database.
 119
 120   $est->add(
 121         id => 42,
 122         ds => $ds,
 123         type => 'display',
 124         text => 'optional text from which snippet is created',
 125   );
 126
 127 This function will create  entries in index using following URI format:
 128
 129   C<file:///type/database%20name/000>
 130
 131 Each tag in C<data_structure> with specified C<type> will create one
 132 attribute and corresponding hidden text (used for search).
 133
 134 =cut
 135
 136 sub add {
 137         my $self = shift;
 138
 139         my $args = {@_};
 140
 141         my $log = $self->_get_logger;
 142
 143         my $database = $self->{'database'} || $log->logconfess('no database in $self');
 144         $log->logconfess('need invindex in object') unless ($self->{'invindex'});
 145
 146         foreach my $p (qw/id ds type/) {
 147                 $log->logdie("need $p") unless ($args->{$p});
 148         }
 149
 150         my $type = $args->{'type'};
 151         my $id = $args->{'id'};
 152
 153         my $uri = "file:///$type/$database/$id";
 154         $log->debug("creating $uri");
 155
 156         my $doc = $self->{invindex}->new_doc( $uri ) || $log->logdie("can't create new_doc( $uri )");
 157         eval { $doc->set_value('uri', $self->convert($uri) ) };
 158
 159         $log->debug("ds = ", sub { Dumper($args->{'ds'}) } );
 160
 161         # filter all tags which have type defined
 162         my @tags = grep {
 163                 ref($args->{'ds'}->{$_}) eq 'HASH' && defined( $args->{'ds'}->{$_}->{$type} )
 164         } keys %{ $args->{'ds'} };
 165
 166         $log->debug("tags = ", join(",", @tags));
 167
 168         return unless (@tags);
 169
 170         foreach my $tag (@tags) {
 171
 172                 my $vals = join(" ", @{ $args->{'ds'}->{$tag}->{$type} });
 173
 174                 next if (! $vals);
 175
 176                 $vals = $self->convert( $vals ) or
 177                         $log->logdie("can't convert '$vals' to UTF-8");
 178
 179                 eval { $doc->set_value( $tag, $vals ) };
 180         }
 181
 182         my $text = $args->{'text'};
 183         if ( $text ) {
 184                 $text = $self->convert( $text ) or
 185                         $log->logdie("can't convert '$text' to UTF-8");
 186                 eval { $doc->set_value( bodytext => $text ) };
 187         }
 188
 189         #$log->debug("adding ", sub { $doc->dump_draft } );
 190         $self->{invindex}->add_doc($doc) || $log->warn("can't add document $uri");
 191
 192         return 1;
 193 }
 194
 195
 196 =head2 convert
 197
 198  my $utf8_string = $self->convert('string in codepage');
 199
 200 =cut
 201
 202 sub convert {
 203         my $self = shift;
 204
 205         my $text = shift || return;
 206         from_to($text, $self->{encoding}, 'UTF-8');
 207         return $text;
 208 }
 209
 210 =head1 AUTHOR
 211
 212 Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>
 213
 214 =head1 COPYRIGHT & LICENSE
 215
 216 Copyright 2005 Dobrica Pavlinusic, All Rights Reserved.
 217
 218 This program is free software; you can redistribute it and/or modify it
 219 under the same terms as Perl itself.
 220
 221 =cut
 222
 223 1; # End of WebPAC::Output::Estraier