blib/lib/POE/Filter/Reference.pm

filter: Statementstmt 93.2% 137 / 147 Branchbran 72.5% 45 / 62 Conditioncond 82.3% 28 / 34 MC/DCmcdc 68.4% 13 / 19 Subroutinesub 100% 20 / 20 Podpod 100% 6 / 6 totaltotal 86.4% 249 / 288 CC 45 SCAR 24.2
CC
45
Cov
86%
new
25.5
get_one
7.1
BEGIN
4.2
CRAP 11.3
« blib/lib/POE/Filter/HTTPD.pm ↑ Summary blib/lib/POE/Resource/Events.pm »
1 # Filter::Reference partial copyright 1998 Artur Bergman
2 # <artur@vogon-solutions.com>. Partial copyright 1999 Philip Gwyn.
3  
4 package POE::Filter::Reference;
5  
6 48 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
7 48 ▶use POE::Filter;
Subroutine BEGIN: called CC=1 SCAR=0.0
8  
9 48 ▶use vars qw($VERSION @ISA);
Subroutine BEGIN: called CC=1 SCAR=0.0
10 48 $VERSION = '1.370'; # NOTE - Should be #.### (three decimal places)
11 48 @ISA = qw(POE::Filter);
12  
13 48 ▶use Carp qw(carp croak confess);
Subroutine BEGIN: called CC=1 SCAR=0.0
14  
15 sub BUFFER () { 0 }
16 sub FREEZE () { 1 }
17 sub THAW () { 2 }
18 sub COMPRESS () { 3 }
19 sub NO_FATALS () { 4 }
20 sub MAX_BUFFER () { 5 }
21 sub BAD_BUFFER () { 6 }
22 sub FIRST_UNUSED () { 7 }
23  
24 48 ▶use base 'Exporter';
Subroutine BEGIN: called CC=1 SCAR=0.0
25 48 our @EXPORT_OK = qw( FIRST_UNUSED );
26  
27 48 my %KNOWN_PARAMS = (
28 Compression => 1,
29 Serializer => 1,
30 NoFatals => 1,
31 MaxBuffer => 1
32 );
33  
34 #------------------------------------------------------------------------------
35 # Try to require one of the default freeze/thaw packages.
36 48 ▶use vars qw( $DEF_FREEZER $DEF_FREEZE $DEF_THAW );
Subroutine BEGIN: called CC=1 SCAR=0.0
37 48 ▶BEGIN {
Subroutine BEGIN: called CC=4 SCAR=14.5
38 48 local $SIG{'__DIE__'} = 'DEFAULT';
39  
40 48 my @packages = qw(Storable FreezeThaw YAML);
41 48 foreach my $package (@packages) {
42 48 eval { require "$package.pm"; import $package (); };
43 48 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 0 48 48
44 0 warn $@;
45 0 next;
46 }
47  
48 # Found a good freezer!
49 48 $DEF_FREEZER = $package;
50 48 last;
51 }
52 48 ▶ die "Filter::Reference requires one of @packages" unless defined $DEF_FREEZER;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $POE::Filter::Reference::DEF_FREEZER 0 48 48
53 }
54  
55 # Some processing here
56 48 ($DEF_FREEZE, $DEF_THAW) = _get_methods($DEF_FREEZER);
57  
58 #------------------------------------------------------------------------------
59 # Try to acquire Compress::Zlib at run time.
60  
61 48 my $zlib_status = undef;
62 1 ▶sub _include_zlib {
Subroutine _include_zlib: called CC=3 SCAR=11.5
63 1 local $SIG{'__DIE__'} = 'DEFAULT';
64  
65 1 ▶ unless (defined $zlib_status) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $zlib_status) 1 0 1
66 1 ▶ eval "use Compress::Zlib qw(compress uncompress)";
Subroutine BEGIN: called CC=1 SCAR=0.0
67 1 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) { } 0 1 1
68 0 $zlib_status = $@;
69 eval(
70 0 "sub compress { @_ }\n" .
71 "sub uncompress { @_ }"
72 );
73 }
74 else {
75 1 $zlib_status = '';
76 }
77 }
78  
79 1 $zlib_status;
80 }
81  
82 #------------------------------------------------------------------------------
83  
84 77 ▶sub _get_methods {
Subroutine _get_methods: called CC=4 SCAR=13.9
85 77 my($freezer)=@_;
86 77 ▶ my $freeze=$freezer->can('nfreeze') || $freezer->can('freeze');
Condition100%3/3
$freezer->can('nfreeze') || $freezer->can('freeze')
l!l&&r!l&&!r
50252
MC/DC100%2/2
$freezer->can('nfreeze') || $freezer->can('freeze')
$freezer->can('nfreeze') $freezer->can('freeze')
Truth table100%3/3
A || B
A= $freezer->can('nfreeze')B= $freezer->can('freeze')
ABresult
1X1
011
000
87 77 my $thaw=$freezer->can('thaw');
88 77 ▶ return unless $freeze and $thaw;
Branch: 1 branch
BranchTrueFalseTotal
unless $freeze and $thaw 2 75 77
Condition66%2/3
$freeze and $thaw
!ll&&!rl&&r
2075
MC/DC50%1/2
$freeze and $thaw
$freeze $thaw
Truth table66%2/3
A and B
A= $freezeB= $thaw
ABresult
0X0
100
111
89 75 return ($freeze, $thaw);
90 }
91  
92 #------------------------------------------------------------------------------
93  
94 sub new
95 160 ▶{
Subroutine new: called CC=23 SCAR=32.4
Pod documented
96 160 my $type = shift;
97  
98 # Convert from old style to new style
99 # $l == 1
100 # ->new( undef ) => (Serializer => undef)
101 # ->new( $class ) => (Serializer => class)
102 # not defined $_[0]
103 # ->new( undef, 1 ) => (Serializer => undef, Compression => 1)
104 # ->new( undef, undef, 1 ) => (Serializer => undef, Compression => undef, NoFatals =>1)
105 # $l == 3
106 # ->new( $class, 1, 1 ) => (Serializer => undef, Compression => 1, NoFatals =>1)
107 # ($l <= 3 and not $KNOWN_PARAMS{$_[0]})
108 # ->new( $class, 1 )
109 160 my %params;
110 160 my $l = scalar @_;
111 160 ▶ if( $l == 1 or $l == 3 or not defined $_[0] or
Branch: 1 branch
BranchTrueFalseTotal
if ($l == 1 or $l == 3 or not defined $_[0] or $l <= 3 and not $KNOWN_PARAMS{$_[0]}) { } 148 12 160
Condition100%12/12
$l == 1 or $l == 3 or not defined $_[0] or $l <= 3 and not $KNOWN_PARAMS{$_[0]}
l!l&&r!l&&!r
147112
$l == 1 or $l == 3 or not defined $_[0]
l!l&&r!l&&!r
2112613
$l == 1 or $l == 3
l!l&&r!l&&!r
165139
$l <= 3 and not $KNOWN_PARAMS{$_[0]}
!ll&&!rl&&r
1111
MC/DC100%5/5
$l == 1 or $l == 3 or not defined $_[0] or $l <= 3 and not $KNOWN_PARAMS{$_[0]}
$l == 1 $l == 3 not defined $_[0] $l <= 3 not $KNOWN_PARAMS{$_[0]}
Truth table100%6/6
A or B or not(C) or D and not(E)
A= $l == 1B= $l == 3C= not defined $_[0]D= $l <= 3E= not $KNOWN_PARAMS{$_[0]}
ABCDEresult
1XXXX1
01XXX1
001XX1
000111
0000X0
000100
112 ( $l<=3 and not $KNOWN_PARAMS{$_[0]}) ) {
113 148 ▶ if( 'HASH' eq ref $_[0] ) { # do we
Branch: 1 branch
BranchTrueFalseTotal
if ('HASH' eq ref $_[0]) { } 0 148 148
114 0 %params = %{ $_[0] };
115 }
116 else {
117 148 %params = ( Serializer => $_[0],
118 Compression => $_[1],
119 NoFatals => $_[2]
120 );
121 }
122 }
123 else {
124 12 ▶ croak "$type requires an even number of parameters" if @_ and @_ & 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ and @_ & 1 0 12 12
Condition33%1/3
@_ and @_ & 1
!ll&&!rl&&r
0120
MC/DC0%0/2
@_ and @_ & 1
@_ @_ & 1
Truth table33%1/3
A and B
A= @_B= @_ & 1
ABresult
0X0
100
111
125 12 %params = @_;
126 }
127  
128 160 my($freeze, $thaw);
129 160 my $freezer = $params{Serializer};
130 160 ▶ unless (defined $freezer) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $freezer) { } 27 133 160
131 # Okay, load the default one!
132 133 $freezer = $DEF_FREEZER;
133 133 $freeze = $DEF_FREEZE;
134 133 $thaw = $DEF_THAW;
135 }
136 else {
137 # What did we get?
138 27 ▶ if (ref $freezer) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $freezer) { } 2 25 27
139 # It's an object, create an closure
140 2 my($freezetmp, $thawtmp) = _get_methods($freezer);
141 2 ▶ $freeze = sub { $freezetmp->($freezer, @_) };
Subroutine __ANON__: called CC=1 SCAR=0.0
142 2 ▶ $thaw = sub { $thawtmp-> ($freezer, @_) };
Subroutine __ANON__: called CC=1 SCAR=0.0
143 }
144 else {
145 # A package name?
146 # First, find out if the package has the necessary methods.
147 25 ($freeze, $thaw) = _get_methods($freezer);
148  
149 # If not, try to reload the module.
150 25 ▶ unless ($freeze and $thaw) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($freeze and $thaw) 2 23 25
Condition66%2/3
$freeze and $thaw
!ll&&!rl&&r
2023
MC/DC50%1/2
$freeze and $thaw
$freeze $thaw
Truth table66%2/3
A and B
A= $freezeB= $thaw
ABresult
0X0
100
111
151 2 my $path = $freezer;
152 2 $path =~ s{::}{/}g;
153 2 $path .= '.pm';
154  
155 # Force a reload if necessary. This is naive and can leak
156 # memory, so we only do it until we get the desired methods.
157 2 delete $INC{$path};
158  
159 2 eval {
160 2 local $^W = 0;
161 2 require $path;
162 2 $freezer->import();
163 };
164  
165 2 ▶ carp $@ if $@;
Branch: 1 branch
BranchTrueFalseTotal
if $@ 0 2 2
166 2 ($freeze, $thaw) = _get_methods($freezer);
167 }
168 }
169 }
170  
171 # Now get the methods we want
172 160 ▶ carp "$freezer doesn't have a freeze or nfreeze method" unless $freeze;
Branch: 1 branch
BranchTrueFalseTotal
unless $freeze 0 160 160
173 160 ▶ carp "$freezer doesn't have a thaw method" unless $thaw;
Branch: 1 branch
BranchTrueFalseTotal
unless $thaw 0 160 160
174  
175 # Should ->new() return undef() it if fails to find the methods it
176 # wants?
177 160 ▶ return unless $freeze and $thaw;
Branch: 1 branch
BranchTrueFalseTotal
unless $freeze and $thaw 0 160 160
Condition33%1/3
$freeze and $thaw
!ll&&!rl&&r
00160
MC/DC0%0/2
$freeze and $thaw
$freeze $thaw
Truth table33%1/3
A and B
A= $freezeB= $thaw
ABresult
0X0
100
111
178  
179 # Maximum buffer
180 160 my $max_buffer = $type->__param_max( MaxBuffer => 512*1024*1024, \%params );
181  
182 # Compression
183 160 ▶ my $compression = $params{Compression}||0;
Condition100%2/2
$params{'Compression'} || 0
l!l
1159
MC/DC100%1/1
$params{'Compression'} || 0
$params{'Compression'}
Truth table100%2/2
A
A= $params{'Compression'}
Aresult
11
00
184 160 ▶ if ($compression) {
Branch: 1 branch
BranchTrueFalseTotal
if ($compression) 1 159 160
185 1 my $zlib_status = _include_zlib();
186 1 ▶ if ($zlib_status ne '') {
Branch: 1 branch
BranchTrueFalseTotal
if ($zlib_status ne "") 0 1 1
187 0 warn "Compress::Zlib load failed with error: $zlib_status\n";
188 0 carp "Filter::Reference compression option ignored";
189 0 $compression = 0;
190 }
191 }
192  
193 # No fatals
194 160 ▶ my $no_fatals = $params{NoFatals}||0;
Condition100%2/2
$params{'NoFatals'} || 0
l!l
4156
MC/DC100%1/1
$params{'NoFatals'} || 0
$params{'NoFatals'}
Truth table100%2/2
A
A= $params{'NoFatals'}
Aresult
11
00
195  
196 160 delete @params{ keys %KNOWN_PARAMS };
197 160 ▶ carp("$type ignores unknown parameters: ", join(', ', sort keys %params))
Branch: 1 branch
BranchTrueFalseTotal
if scalar keys %params 10 150 160
198 if scalar keys %params;
199  
200 160 my $self = bless [
201 '', # BUFFER
202 $freeze, # FREEZE
203 $thaw, # THAW
204 $compression, # COMPRESS
205 $no_fatals, # NO_FATALS
206 $max_buffer, # MAX_BUFFER
207 '' # BAD_BUFFER
208 ], $type;
209 160 $self;
210 }
211  
212 #------------------------------------------------------------------------------
213  
214 49 ▶sub get {
Subroutine get: called CC=2 SCAR=6.9
Pod documented
215 49 my ($self, $stream) = @_;
216 49 my @return;
217  
218 49 $self->get_one_start($stream);
219 49 while (1) {
220 109 my $next = $self->get_one();
221 108 ▶ last unless @$next;
Branch: 1 branch
BranchTrueFalseTotal
unless @$next 48 60 108
222 60 push @return, @$next;
223 }
224  
225 48 return \@return;
226 }
227  
228 #------------------------------------------------------------------------------
229 # 2001-07-27 RCC: The get_one() variant of get() allows Wheel::Xyz to
230 # retrieve one filtered block at a time. This is necessary for filter
231 # changing and proper input flow control.
232  
233 69 ▶sub get_one_start {
Subroutine get_one_start: called CC=3 SCAR=11.0
Pod documented
234 69 my ($self, $stream) = @_;
235 69 $self->[BUFFER] .= join('', @$stream);
236 69 ▶ if( $self->[MAX_BUFFER] < length( $self->[BUFFER] ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->[5] < length $self->[0]) 1 68 69
237 1 $self->[BAD_BUFFER] = "Framing buffer exceeds the limit";
238 1 ▶ die $self->[BAD_BUFFER] unless $self->[NO_FATALS];
Branch: 1 branch
BranchTrueFalseTotal
unless $self->[4] 0 1 1
239 }
240 }
241  
242 147 ▶sub get_one {
Subroutine get_one: called CC=7 SCAR=19.6
Pod documented
243 147 my $self = shift;
244  
245 # Need to check lengths in octets, not characters.
246 48 ▶ BEGIN { eval { require bytes } and bytes->import; }
Subroutine BEGIN: called CC=2 SCAR=7.2
Branch: 1 branch
BranchTrueFalseTotal
eval { do { require bytes } } and "bytes"->import 48 0 48
247  
248 147 ▶ if( $self->[BAD_BUFFER] ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->[6]) 1 146 147
249 1 my $err = $self->[BAD_BUFFER];
250 1 $self->[BAD_BUFFER] = '';
251 1 return [ $err ];
252 }
253  
254 146 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if ($self->[0] =~ /^(\d+)\0/ and length $self->[0] >= $1 + length($1) + 1) 82 64 146
Condition100%3/3
$self->[0] =~ /^(\d+)\0/ and length $self->[0] >= $1 + length($1) + 1
!ll&&!rl&&r
63182
MC/DC100%2/2
$self->[0] =~ /^(\d+)\0/ and length $self->[0] >= $1 + length($1) + 1
$self->[0] =~ /^(\d+)\0/ length $self->[0] >= $1 + length($1) + 1
Truth table100%3/3
A and B
A= $self->[0] =~ /^(\d+)\0/B= length $self->[0] >= $1 + length($1) + 1
ABresult
0X0
100
111
255 $self->[BUFFER] =~ /^(\d+)\0/ and
256 length($self->[BUFFER]) >= $1 + length($1) + 1
257 ) {
258 82 substr($self->[BUFFER], 0, length($1) + 1) = "";
259 82 my $next_message = substr($self->[BUFFER], 0, $1);
260 82 substr($self->[BUFFER], 0, $1) = "";
261 82 ▶ $next_message = uncompress($next_message) if $self->[COMPRESS];
Branch: 1 branch
BranchTrueFalseTotal
if $self->[3] 0 82 82
262  
263 82 ▶ unless ($self->[NO_FATALS]) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->[4]) 79 3 82
264 79 return [ $self->[THAW]->($next_message) ];
265 }
266  
267 3 my $thawed = eval { $self->[THAW]->($next_message) };
268 3 ▶ return [ "$@" ] if $@;
Branch: 1 branch
BranchTrueFalseTotal
if $@ 3 0 3
269 0 return [ $thawed ];
270 }
271  
272 64 return [ ];
273 }
274  
275 #------------------------------------------------------------------------------
276 # freeze one or more references, and return a string representing them
277  
278 118 ▶sub put {
Subroutine put: called CC=3 SCAR=11.1
Pod documented
279 118 my ($self, $references) = @_;
280  
281 # Need to check lengths in octets, not characters.
282 48 ▶ BEGIN { eval { require bytes } and bytes->import; }
Subroutine BEGIN: called CC=2 SCAR=7.2
Branch: 1 branch
BranchTrueFalseTotal
eval { do { require bytes } } and "bytes"->import 48 0 48
283  
284 my @raw = map {
285 118 ▶ confess "Choking on a non-reference ($_)" unless ref();
Branch: 1 branch
BranchTrueFalseTotal
unless ref $_ 0 128 128
286 128 my $frozen = $self->[FREEZE]->($_);
287 128 ▶ $frozen = compress($frozen) if $self->[COMPRESS];
Branch: 1 branch
BranchTrueFalseTotal
if $self->[3] 1 127 128
288 128 length($frozen) . "\0" . $frozen;
289 } @$references;
290 118 \@raw;
291 }
292  
293 #------------------------------------------------------------------------------
294 # Return everything we have outstanding. Do not destroy our framing
295 # buffer, though.
296  
297 13 ▶sub get_pending {
Subroutine get_pending: called CC=2 SCAR=6.9
Pod documented
298 13 my $self = shift;
299 13 ▶ return undef unless length $self->[BUFFER];
Branch: 1 branch
BranchTrueFalseTotal
unless length $self->[0] 8 5 13
300 5 return [ $self->[BUFFER] ];
301 }
302  
303 48 1;
304  
305 __END__
« blib/lib/POE/Filter/HTTPD.pm ↑ Summary blib/lib/POE/Resource/Events.pm »