Grep/Search/KinoSearch.pm

package Grep::Search::KinoSearch;

use strict;
use warnings;

use Data::Dump qw/dump/;
use KinoSearch::InvIndexer;
use KinoSearch::Searcher;
use Jifty::Util;

my $debug = 1;

=head1 NAME

Grep::Search::KinoSearch - full text search using L<KinoSearch>

=head1 METHODS

=head2 invindexer

Accessor to call any method defined on L<KinoSearch::InvIndexer>

  $search->invindexer->delete_by_term( 'id', 42 );

=cut

our $indexes;

sub invindexer {
        my $self = shift;
        my $invindexer;
        my $index_path = Jifty::Util->app_root . '/var/invindex';

        if ( $invindexer = $indexes->{$index_path} ) {
                $self->log->debug("Using cached index $index_path");
        } else {
                if ( $self->create || -e $index_path ) {
                        $self->log->debug("Creating new index $index_path");
                        $invindexer = KinoSearch::InvIndexer->new( invindex => Grep::Search::KinoSearch::Schema->clobber( $index_path ) )
                                or die "can't create index $index_path: $!";
                        $self->create( 0 );
                } else {
                        $self->log->debug("Opening index: $index_path");
                        $invindexer = KinoSearch::InvIndexer->new( invindex => Grep::Search::KinoSearch::Schema->open( $index_path ) )
                                or die "can't open index $index_path: $!";
                }
                $indexes->{$index_path} = $invindexer;
        }

        return $invindexer;
}

=head2 add

  $search->add( $doc_hash );

=cut

sub add {
        my $self = shift;
        my $doc = shift;
        $self->invindexer->add_doc( $doc );
        return 1;
}

=head2 search

  my $fetch_hit_coderef = $self->search('search query');

=cut

sub search {
        my $self = shift;

        my $q = shift or die "no q?";

        my $index_path = Jifty::Util->app_root . '/var/invindex';
        my $searcher = KinoSearch::Searcher->new(
                invindex => Grep::Search::KinoSearch::Schema->open( $index_path ), );
        $self->log->debug("$searcher created");

        my $full_q = "($q)";

        my $uid = Jifty->web->current_user->id;
        $full_q .= ' AND _owner_id:' . $uid if (defined $uid);

        $self->log->debug("searching for '$q' using $full_q");

        my $query_parser = KinoSearch::QueryParser->new(
                schema => Grep::Search::KinoSearch::Schema->new,
                fields => [ qw/ title link content summary category author / ],
        );
        $query_parser->set_heed_colons(1);       # enable field:value AND/OR/NOT syntax
        my $query = $query_parser->parse( $full_q );
        my $hits = $searcher->search(
                query           => $query,
#               offset          => $offset,
#               num_wanted      => $hits_per_page,
        );

        $self->hits( $hits->total_hits );

        return sub {
                return $hits->fetch_hit;
        };
}

=head2 finish

  $search->finish

=cut

sub finish {
        my $self = shift;
        if ($self->invindexer) {
                $self->log->debug("closing index");
                $self->invindexer->finish;
        }

        $self->log->debug("finish");

        undef $self;

        return 1;
}

package Grep::Search::KinoSearch::KeywordField;
use base qw( KinoSearch::Schema::FieldSpec );
sub analyzed { 0 }
#sub indexed { 1 }
#sub stored { 1 }
sub vectorized { 0 }

package Grep::Search::KinoSearch::Schema;

=head1 NAME

Grep::Search::KinoSearch::Schema - schema definition for full-text search

=cut

use base 'KinoSearch::Schema';
use KinoSearch::Analysis::PolyAnalyzer;

our %fields = (
        id                              => 'Grep::Search::KinoSearch::KeywordField',

        in_feed_id              => 'Grep::Search::KinoSearch::KeywordField',
        in_feed_url             => 'Grep::Search::KinoSearch::KeywordField',
        in_feed_title   => 'KinoSearch::Schema::FieldSpec',
        in_feed_owner   => 'Grep::Search::KinoSearch::KeywordField',
        in_feed_created_on      => 'Grep::Search::KinoSearch::KeywordField',

        title                   => 'KinoSearch::Schema::FieldSpec',
        link                    => 'Grep::Search::KinoSearch::KeywordField',
        content                 => 'KinoSearch::Schema::FieldSpec',
        summary                 => 'KinoSearch::Schema::FieldSpec',
        category                => 'KinoSearch::Schema::FieldSpec',
        author                  => 'KinoSearch::Schema::FieldSpec',
        created_on              => 'Grep::Search::KinoSearch::KeywordField',
        last_update             => 'Grep::Search::KinoSearch::KeywordField',

        _owner_id               => 'Grep::Search::KinoSearch::KeywordField',
);

sub analyzer {
        return KinoSearch::Analysis::PolyAnalyzer->new( language => 'en' );
}

1;
1	dpavlin	189	package Grep::Search::KinoSearch;
2	dpavlin	47
3			use strict;
4			use warnings;
5
6			use Data::Dump qw/dump/;
7	dpavlin	127	use KinoSearch::InvIndexer;
8			use KinoSearch::Searcher;
9	dpavlin	47	use Jifty::Util;
10
11	dpavlin	190	my $debug = 1;
12	dpavlin	47
13	dpavlin	109	=head1 NAME
14	dpavlin	47
15	dpavlin	189	Grep::Search::KinoSearch - full text search using L<KinoSearch>
16	dpavlin	47
17	dpavlin	109	=head1 METHODS
18	dpavlin	47
19	dpavlin	185	=head2 invindexer
20
21			Accessor to call any method defined on L<KinoSearch::InvIndexer>
22
23			$search->invindexer->delete_by_term( 'id', 42 );
24
25			=cut
26
27	dpavlin	189	our $indexes;
28	dpavlin	185
29			sub invindexer {
30			my $self = shift;
31			my $invindexer;
32	dpavlin	190	my $index_path = Jifty::Util->app_root . '/var/invindex';
33	dpavlin	185
34			if ( $invindexer = $indexes->{$index_path} ) {
35			$self->log->debug("Using cached index $index_path");
36	dpavlin	47	} else {
37	dpavlin	189	if ( $self->create \|\| -e $index_path ) {
38	dpavlin	185	$self->log->debug("Creating new index $index_path");
39	dpavlin	189	$invindexer = KinoSearch::InvIndexer->new( invindex => Grep::Search::KinoSearch::Schema->clobber( $index_path ) )
40			or die "can't create index $index_path: $!";
41			$self->create( 0 );
42	dpavlin	185	} else {
43			$self->log->debug("Opening index: $index_path");
44	dpavlin	189	$invindexer = KinoSearch::InvIndexer->new( invindex => Grep::Search::KinoSearch::Schema->open( $index_path ) )
45			or die "can't open index $index_path: $!";
46	dpavlin	185	}
47			$indexes->{$index_path} = $invindexer;
48	dpavlin	47	}
49
50	dpavlin	189	return $invindexer;
51	dpavlin	49	}
52
53	dpavlin	47	=head2 add
54
55	dpavlin	190	$search->add( $doc_hash );
56	dpavlin	47
57			=cut
58
59			sub add {
60			my $self = shift;
61	dpavlin	190	my $doc = shift;
62	dpavlin	127	$self->invindexer->add_doc( $doc );
63	dpavlin	151	return 1;
64	dpavlin	47	}
65
66	dpavlin	190	=head2 search
67	dpavlin	47
68	dpavlin	190	my $fetch_hit_coderef = $self->search('search query');
69	dpavlin	141
70	dpavlin	47	=cut
71
72	dpavlin	190	sub search {
73	dpavlin	47	my $self = shift;
74
75			my $q = shift or die "no q?";
76
77	dpavlin	190	my $index_path = Jifty::Util->app_root . '/var/invindex';
78	dpavlin	127	my $searcher = KinoSearch::Searcher->new(
79	dpavlin	190	invindex => Grep::Search::KinoSearch::Schema->open( $index_path ), );
80	dpavlin	98	$self->log->debug("$searcher created");
81	dpavlin	47
82	dpavlin	151	my $full_q = "($q)";
83	dpavlin	64
84	dpavlin	151	my $uid = Jifty->web->current_user->id;
85	dpavlin	153	$full_q .= ' AND _owner_id:' . $uid if (defined $uid);
86	dpavlin	151
87	dpavlin	127	$self->log->debug("searching for '$q' using $full_q");
88	dpavlin	153
89			my $query_parser = KinoSearch::QueryParser->new(
90	dpavlin	189	schema => Grep::Search::KinoSearch::Schema->new,
91	dpavlin	153	fields => [ qw/ title link content summary category author / ],
92			);
93			$query_parser->set_heed_colons(1); # enable field:value AND/OR/NOT syntax
94			my $query = $query_parser->parse( $full_q );
95	dpavlin	127	my $hits = $searcher->search(
96	dpavlin	153	query => $query,
97	dpavlin	127	# offset => $offset,
98			# num_wanted => $hits_per_page,
99			);
100	dpavlin	64
101	dpavlin	141	$self->hits( $hits->total_hits );
102	dpavlin	47
103	dpavlin	190	return sub {
104			return $hits->fetch_hit;
105			};
106	dpavlin	47	}
107
108			=head2 finish
109
110	dpavlin	109	$search->finish
111	dpavlin	47
112			=cut
113
114			sub finish {
115			my $self = shift;
116	dpavlin	127	if ($self->invindexer) {
117	dpavlin	102	$self->log->debug("closing index");
118	dpavlin	127	$self->invindexer->finish;
119	dpavlin	47	}
120	dpavlin	58
121	dpavlin	110	$self->log->debug("finish");
122
123	dpavlin	112	undef $self;
124
125	dpavlin	151	return 1;
126	dpavlin	47	}
127
128	dpavlin	189	package Grep::Search::KinoSearch::KeywordField;
129	dpavlin	127	use base qw( KinoSearch::Schema::FieldSpec );
130			sub analyzed { 0 }
131	dpavlin	153	#sub indexed { 1 }
132			#sub stored { 1 }
133			sub vectorized { 0 }
134	dpavlin	127
135	dpavlin	189	package Grep::Search::KinoSearch::Schema;
136	dpavlin	127
137			=head1 NAME
138
139	dpavlin	189	Grep::Search::KinoSearch::Schema - schema definition for full-text search
140	dpavlin	127
141			=cut
142
143			use base 'KinoSearch::Schema';
144			use KinoSearch::Analysis::PolyAnalyzer;
145
146	dpavlin	131	our %fields = (
147	dpavlin	189	id => 'Grep::Search::KinoSearch::KeywordField',
148	dpavlin	127
149	dpavlin	189	in_feed_id => 'Grep::Search::KinoSearch::KeywordField',
150			in_feed_url => 'Grep::Search::KinoSearch::KeywordField',
151	dpavlin	127	in_feed_title => 'KinoSearch::Schema::FieldSpec',
152	dpavlin	189	in_feed_owner => 'Grep::Search::KinoSearch::KeywordField',
153			in_feed_created_on => 'Grep::Search::KinoSearch::KeywordField',
154	dpavlin	127
155			title => 'KinoSearch::Schema::FieldSpec',
156	dpavlin	189	link => 'Grep::Search::KinoSearch::KeywordField',
157	dpavlin	127	content => 'KinoSearch::Schema::FieldSpec',
158			summary => 'KinoSearch::Schema::FieldSpec',
159			category => 'KinoSearch::Schema::FieldSpec',
160			author => 'KinoSearch::Schema::FieldSpec',
161	dpavlin	189	created_on => 'Grep::Search::KinoSearch::KeywordField',
162			last_update => 'Grep::Search::KinoSearch::KeywordField',
163	dpavlin	127
164	dpavlin	189	_owner_id => 'Grep::Search::KinoSearch::KeywordField',
165	dpavlin	127	);
166
167			sub analyzer {
168			return KinoSearch::Analysis::PolyAnalyzer->new( language => 'en' );
169			}
170
171	dpavlin	47	1;