File Coverage

blib/lib/Lucy.pm
Criterion Covered Total %
statement 104 123 84.5
branch 13 26 50.0
condition 3 11 27.2
subroutine 38 43 88.3
pod 7 14 50.0
total 165 217 76.0


line stmt bran cond sub pod time code
1             # Licensed to the Apache Software Foundation (ASF) under one or more
2             # contributor license agreements. See the NOTICE file distributed with
3             # this work for additional information regarding copyright ownership.
4             # The ASF licenses this file to You under the Apache License, Version 2.0
5             # (the "License"); you may not use this file except in compliance with
6             # the License. You may obtain a copy of the License at
7             #
8             # http://www.apache.org/licenses/LICENSE-2.0
9             #
10             # Unless required by applicable law or agreed to in writing, software
11             # distributed under the License is distributed on an "AS IS" BASIS,
12             # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13             # See the License for the specific language governing permissions and
14             # limitations under the License.
15              
16 154     154   3520 use strict;
  154         167  
  154         3442  
17 154     154   449 use warnings;
  154         145  
  154         3580  
18              
19             package Lucy;
20              
21 154     154   2726 use 5.008003;
  154         352  
22              
23             our $VERSION = '0.006000_002';
24             $VERSION = eval $VERSION;
25             our $MAJOR_VERSION = 0.006000;
26              
27 154     154   55145 use Clownfish 0.006000;
  154         726569  
  154         9295  
28             BEGIN {
29 154 50   154   3326 die <<"EOF" if $Clownfish::MAJOR_VERSION > 0.006000;
30             This version of Lucy doesn't support Clownfish $Clownfish::MAJOR_VERSION or
31             higher. You should downgrade Clownfish or, if possible, upgrade Lucy.
32             EOF
33             }
34              
35 154     154   1254 use Exporter 'import';
  154         1313  
  154         5373  
36             BEGIN {
37 154     154   7590 our @EXPORT_OK = qw(
38             STORABLE_freeze
39             STORABLE_thaw
40             );
41             }
42              
43             # On most UNIX variants, this flag makes DynaLoader pass RTLD_GLOBAL to
44             # dl_open, so extensions can resolve the needed symbols without explicitly
45             # linking against the DSO.
46 154     154 1 1065493 sub dl_load_flags { 1 }
47              
48             BEGIN {
49 154     154   1289 require DynaLoader;
50 154         1072 our @ISA = qw( DynaLoader );
51             # This loads a large number of disparate subs.
52 154         14227 bootstrap Lucy '0.6.0_2';
53             }
54              
55             {
56             package Lucy::Util::IndexFileNames;
57             our $VERSION = '0.006000_002';
58             $VERSION = eval $VERSION;
59             BEGIN {
60 154     154   1112 push our @ISA, 'Exporter';
61 154         5343 our @EXPORT_OK = qw(
62             extract_gen
63             latest_snapshot
64             );
65             }
66             }
67              
68             {
69             # Temporary back compat.
70             package Lucy::Object::Obj;
71 154     154   21749 BEGIN { our @ISA = qw( Clownfish::Obj ) }
72             }
73              
74             {
75             package Lucy::Analysis::RegexTokenizer;
76             our $VERSION = '0.006000_002';
77             $VERSION = eval $VERSION;
78              
79 31     31   8115 sub _compile_token_re {qr/$_[0]/}
80              
81             sub new {
82 13     13 1 8376 my ( $either, %args ) = @_;
83 13         22 my $token_re = delete $args{token_re};
84 13 100       33 $args{pattern} = "$token_re" if $token_re;
85 13         160 return $either->_new(%args);
86             }
87             }
88              
89             {
90             package Lucy::Document::Doc;
91             our $VERSION = '0.006000_002';
92             $VERSION = eval $VERSION;
93 154     154   87507 use Storable (); # Needed by serialize/deserialize.
  154         322746  
  154         4843  
94 154     154   750 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         149  
  154         9879  
95              
96             use overload
97 154         990 fallback => 1,
98 154     154   599 '%{}' => \&get_fields;
  154         161  
99             }
100              
101             {
102             package Lucy::Index::DocVector;
103             our $VERSION = '0.006000_002';
104             $VERSION = eval $VERSION;
105 154     154   12448 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         182  
  154         23301  
106             }
107              
108             {
109             package Lucy::Index::Indexer;
110             our $VERSION = '0.006000_002';
111             $VERSION = eval $VERSION;
112              
113             sub new {
114 311     311 1 1293414 my ( $either, %args ) = @_;
115 311         403 my $flags = 0;
116 311 100       792 $flags |= CREATE if delete $args{'create'};
117 311 100       648 $flags |= TRUNCATE if delete $args{'truncate'};
118 311         79003 return $either->_new( %args, flags => $flags );
119             }
120             }
121              
122             {
123             package Lucy::Index::IndexReader;
124             our $VERSION = '0.006000_002';
125             $VERSION = eval $VERSION;
126 154     154   626 use Carp;
  154         158  
  154         26804  
127              
128             sub new {
129 0     0 1 0 confess(
130             "IndexReader is an abstract class; use open() instead of new()");
131             }
132             sub lexicon {
133 0     0 0 0 my $self = shift;
134 0         0 my $lex_reader = $self->fetch("Lucy::Index::LexiconReader");
135 0 0       0 return $lex_reader->lexicon(@_) if $lex_reader;
136 0         0 return;
137             }
138             sub posting_list {
139 0     0 0 0 my $self = shift;
140 0         0 my $plist_reader = $self->fetch("Lucy::Index::PostingListReader");
141 0 0       0 return $plist_reader->posting_list(@_) if $plist_reader;
142 0         0 return;
143             }
144 1     1 1 4515 sub offsets { shift->_offsets->to_arrayref }
145             }
146              
147             {
148             package Lucy::Index::Similarity;
149             our $VERSION = '0.006000_002';
150             $VERSION = eval $VERSION;
151 154     154   695 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         173  
  154         9490  
152             }
153              
154             {
155             package Lucy::Index::TermVector;
156             our $VERSION = '0.006000_002';
157             $VERSION = eval $VERSION;
158 154     154   600 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         191  
  154         10556  
159             }
160              
161             {
162             package Lucy::Search::Compiler;
163             our $VERSION = '0.006000_002';
164             $VERSION = eval $VERSION;
165 154     154   583 use Carp;
  154         166  
  154         7631  
166 154     154   577 use Scalar::Util qw( blessed );
  154         176  
  154         20753  
167              
168             sub new {
169 506     506 1 3889 my ( $either, %args ) = @_;
170 506 50       680 if ( !defined $args{boost} ) {
171             confess("'parent' is not a Query")
172             unless ( blessed( $args{parent} )
173 0 0 0     0 and $args{parent}->isa("Lucy::Search::Query") );
174 0         0 $args{boost} = $args{parent}->get_boost;
175             }
176 506         1590 return $either->do_new(%args);
177             }
178             }
179              
180             {
181             package Lucy::Search::MatchDoc;
182             our $VERSION = '0.006000_002';
183             $VERSION = eval $VERSION;
184 154     154   630 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         151  
  154         13143  
185             }
186              
187             {
188             package Lucy::Search::Query;
189             our $VERSION = '0.006000_002';
190             $VERSION = eval $VERSION;
191 154     154   628 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         153  
  154         10181  
192             }
193              
194             {
195             package Lucy::Search::SortRule;
196             our $VERSION = '0.006000_002';
197             $VERSION = eval $VERSION;
198 154     154   531 use Carp;
  154         160  
  154         6501  
199 154     154   576 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         165  
  154         21180  
200              
201             my %types = (
202             field => FIELD(),
203             score => SCORE(),
204             doc_id => DOC_ID(),
205             );
206              
207             sub new {
208 36     36 1 16678 my ( $either, %args ) = @_;
209 36   100     165 my $type = delete $args{type} || 'field';
210 36 50       72 confess("Invalid type: '$type'") unless defined $types{$type};
211 36         402 return $either->_new( %args, type => $types{$type} );
212             }
213             }
214              
215             {
216             package Lucy::Search::SortSpec;
217             our $VERSION = '0.006000_002';
218             $VERSION = eval $VERSION;
219 154     154   607 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         179  
  154         8857  
220             }
221              
222             {
223             package Lucy::Search::TopDocs;
224             our $VERSION = '0.006000_002';
225             $VERSION = eval $VERSION;
226 154     154   637 use Lucy qw( STORABLE_freeze STORABLE_thaw );
  154         159  
  154         17569  
227             }
228              
229             {
230             package Lucy::Object::BitVector;
231             our $VERSION = '0.006000_002';
232             $VERSION = eval $VERSION;
233 29     29 0 4217 sub to_arrayref { shift->to_array->to_arrayref }
234             }
235              
236             {
237             package Lucy::Store::FileHandle;
238             our $VERSION = '0.006000_002';
239             $VERSION = eval $VERSION;
240             BEGIN {
241 154     154   2722 push our @ISA, 'Exporter';
242 154         43641 our @EXPORT_OK = qw( build_fh_flags );
243             }
244              
245             sub build_fh_flags {
246 3     3 0 2 my $args = shift;
247 3         4 my $flags = 0;
248 3 50       14 $flags |= FH_CREATE if delete $args->{create};
249 3 50       7 $flags |= FH_READ_ONLY if delete $args->{read_only};
250 3 50       8 $flags |= FH_WRITE_ONLY if delete $args->{write_only};
251 3 50       8 $flags |= FH_EXCLUSIVE if delete $args->{exclusive};
252 3         4 return $flags;
253             }
254              
255             sub open {
256 0     0 0 0 my ( $either, %args ) = @_;
257 0   0     0 $args{flags} ||= 0;
258 0         0 $args{flags} |= build_fh_flags( \%args );
259 0         0 return $either->_open(%args);
260             }
261             }
262              
263             {
264             package Lucy::Store::FSFileHandle;
265             our $VERSION = '0.006000_002';
266             $VERSION = eval $VERSION;
267              
268             sub open {
269 3     3 0 2229 my ( $either, %args ) = @_;
270 3   50     16 $args{flags} ||= 0;
271 3         9 $args{flags} |= Lucy::Store::FileHandle::build_fh_flags( \%args );
272 3         152 return $either->_open(%args);
273             }
274             }
275              
276             {
277             package Lucy::Store::RAMFileHandle;
278             our $VERSION = '0.006000_002';
279             $VERSION = eval $VERSION;
280              
281             sub open {
282 0     0 0   my ( $either, %args ) = @_;
283 0   0       $args{flags} ||= 0;
284 0           $args{flags} |= Lucy::Store::FileHandle::build_fh_flags( \%args );
285 0           return $either->_open(%args);
286             }
287             }
288              
289             {
290             package Lucy::Util::Debug;
291             our $VERSION = '0.006000_002';
292             $VERSION = eval $VERSION;
293             BEGIN {
294 154     154   898 push our @ISA, 'Exporter';
295 154         9342 our @EXPORT_OK = qw(
296             DEBUG
297             DEBUG_PRINT
298             DEBUG_ENABLED
299             ASSERT
300             set_env_cache
301             num_allocated
302             num_freed
303             num_globals
304             );
305             }
306             }
307              
308             {
309             package Lucy::Util::StringHelper;
310             our $VERSION = '0.006000_002';
311             $VERSION = eval $VERSION;
312             BEGIN {
313 154     154   770 push our @ISA, 'Exporter';
314 154         6334 our @EXPORT_OK = qw(
315             utf8_flag_on
316             utf8_flag_off
317             to_base36
318             utf8ify
319             utf8_valid
320             cat_bytes
321             );
322             }
323             }
324              
325             1;
326              
327             __END__