blib/lib/Venus/What.pm

filter: Statementstmt 99.7% 405 / 406 Branchbran 87.7% 86 / 98 Conditioncond 79.1% 38 / 48 MC/DCmcdc 60.0% 15 / 25 Subroutinesub 100% 150 / 150 Podpod 5.9% 8 / 134 totaltotal 81.5% 702 / 861 CC 68 SCAR 11.5
CC
68
Cov
96%
identify
12.0
detract_deep
11.2
deduce_deep
9.2
CRAP 3.1
« blib/lib/Venus/Search.pm ↑ Summary blib/lib/Venus/Enum.pm »
1 package Venus::What;
2  
3 119 ▶use 5.018;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 119 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 119 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 # IMPORTS
9  
10 119 ▶use Venus::Class 'base', 'with';
Subroutine BEGIN: called CC=1 SCAR=0.0
11  
12 # INHERITS
13  
14 119 base 'Venus::Kind::Utility';
15  
16 # INTEGRATES
17  
18 119 with 'Venus::Role::Valuable';
19 119 with 'Venus::Role::Buildable';
20 119 with 'Venus::Role::Accessible';
21  
22 119 ▶use Scalar::Util ();
Subroutine BEGIN: called CC=1 SCAR=0.0
23  
24 # BUILDERS
25  
26 6619 ▶sub build_arg {
Subroutine build_arg: called CC=1 SCAR=0.0
Pod undocumented
27 6619 my ($self, $data) = @_;
28  
29 return {
30 6619 value => $data
31 };
32 }
33  
34 8400 ▶sub build_args {
Subroutine build_args: called CC=4 SCAR=13.9
Pod undocumented
35 8400 my ($self, $data) = @_;
36  
37 8400 ▶ if (keys %$data == 1 && exists $data->{value}) {
Branch: 2 branches
BranchTrueFalseTotal
if (keys %$data == 1 and exists $data->{'value'}) { } 8380 20 8400
elsif (keys %$data) { } 19 1 20
Condition100%3/3
keys %$data == 1 and exists $data->{"value"}
!ll&&!rl&&r
1288380
MC/DC100%2/2
keys %$data == 1 and exists $data->{"value"}
keys %$data == 1 exists $data->{"value"}
Truth table100%3/3
A and B
A= keys %$data == 1B= exists $data->{"value"}
ABresult
0X0
100
111
38 8380 return $data;
39 }
40 elsif (keys %$data) {
41 return {
42 19 value => $data,
43 }
44 }
45 else {
46 return {
47 1 value => $self->default
48 };
49 }
50 }
51  
52 32 ▶sub build_nil {
Subroutine build_nil: called CC=1 SCAR=0.0
Pod undocumented
53 32 my ($self, $data) = @_;
54  
55 return {
56 32 value => $data
57 };
58 }
59  
60 # METHODS
61  
62 114 ▶sub cast {
Subroutine cast: called CC=4 SCAR=14.2
Pod undocumented
63 114 my ($self, $kind, $callback, @args) = @_;
64  
65 114 my $code = $self->code;
66  
67 114 ▶ return undef if !$code;
Branch: 1 branch
BranchTrueFalseTotal
unless $code 0 114 114
68  
69 114 ▶ my $method = join '_', map lc, 'from', $code, 'to', $kind || $code;
Condition66%2/3
$kind || $code
l!l&&r!l&&!r
11310
MC/DC0%0/2
$kind || $code
$kind $code
Truth table66%2/3
A || B
A= $kindB= $code
ABresult
1X1
011
000
70  
71 114 my $result = $self->$method($self->value);
72  
73 114 local $_ = $result;
74  
75 114 ▶ $result = Venus::What->new($result->$callback(@args))->deduce if $callback;
Branch: 1 branch
BranchTrueFalseTotal
if $callback 0 114 114
76  
77 114 return $result;
78 }
79  
80 910 ▶sub code {
Subroutine code: called CC=1 SCAR=0.0
Pod documented
81 910 my ($self) = @_;
82  
83 910 return scalar $self->identify;
84 }
85  
86 793 ▶sub coded {
Subroutine coded: called CC=1 SCAR=0.0
Pod documented
87 793 my ($self, $code) = @_;
88  
89 793 return uc($self->code) eq uc("$code");
90 }
91  
92 3549 ▶sub deduce {
Subroutine deduce: called CC=3 SCAR=11.0
Pod documented
93 3549 my ($self) = @_;
94  
95 3549 my $data = $self->get;
96  
97 3549 ▶ return $self->into_undef if not(defined($data));
Branch: 1 branch
BranchTrueFalseTotal
unless defined $data 127 3422 3549
98 3422 ▶ return $self->deduce_blessed if scalar_is_blessed($data);
Branch: 1 branch
BranchTrueFalseTotal
if scalar_is_blessed($data) 941 2481 3422
99 2481 return $self->deduce_defined;
100 }
101  
102 4 ▶sub deduce_boolean {
Subroutine deduce_boolean: called CC=1 SCAR=0.0
Pod undocumented
103 4 my ($self) = @_;
104  
105 4 my $data = $self->get;
106  
107 4 return $self->into_boolean;
108 }
109  
110 941 ▶sub deduce_blessed {
Subroutine deduce_blessed: called CC=2 SCAR=6.9
Pod undocumented
111 941 my ($self) = @_;
112  
113 941 my $data = $self->get;
114  
115 941 ▶ return $self->into_regexp if $data->isa('Regexp');
Branch: 1 branch
BranchTrueFalseTotal
if $data->isa("Regexp") 3 938 941
116 938 return $data;
117 }
118  
119 4 ▶sub deduce_deep {
Subroutine deduce_deep: called CC=9 SCAR=22.2
Pod documented
120 4 my ($self) = @_;
121  
122 4 my $data = $self->deduce;
123  
124 4 ▶ if ($data and $data->isa('Venus::Hash')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($data and $data->isa("Venus::Hash")) 2 2 4
Condition66%2/3
$data and $data->isa("Venus::Hash")
!ll&&!rl&&r
022
MC/DC50%1/2
$data and $data->isa("Venus::Hash")
$data $data->isa("Venus::Hash")
Truth table66%2/3
A and B
A= $dataB= $data->isa("Venus::Hash")
ABresult
0X0
100
111
125 2 for my $i (keys %{$data->get}) {
126 4 my $val = $data->get->{$i};
127 4 ▶ $data->get->{$i} = ref($val)
Branch: 1 branch
BranchTrueFalseTotal
ref $val ? : 0 4 4
128 ? $self->class->new(value => $val)->deduce_deep
129 : $self->class->new(value => $val)->deduce;
130 }
131 }
132 4 ▶ if ($data and $data->isa('Venus::Array')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($data and $data->isa("Venus::Array")) 2 2 4
Condition66%2/3
$data and $data->isa("Venus::Array")
!ll&&!rl&&r
022
MC/DC50%1/2
$data and $data->isa("Venus::Array")
$data $data->isa("Venus::Array")
Truth table66%2/3
A and B
A= $dataB= $data->isa("Venus::Array")
ABresult
0X0
100
111
133 2 ▶ for (my $i = 0; $i < @{$data->get}; $i++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < @{$data->get;}) 8 2 10
134 8 my $val = $data->get->[$i];
135 8 ▶ $data->get->[$i] = ref($val)
Branch: 1 branch
BranchTrueFalseTotal
ref $val ? : 0 8 8
136 ? $self->class->new(value => $val)->deduce_deep
137 : $self->class->new(value => $val)->deduce;
138 }
139 }
140  
141 4 return $data;
142 }
143  
144 2481 ▶sub deduce_defined {
Subroutine deduce_defined: called CC=5 SCAR=16.1
Pod undocumented
145 2481 my ($self) = @_;
146  
147 2481 my $data = $self->get;
148  
149 2481 ▶ return $self->deduce_references if ref($data);
Branch: 1 branch
BranchTrueFalseTotal
if ref $data 62 2419 2481
150 2419 ▶ return $self->deduce_boolean if scalar_is_boolean($data);
Branch: 1 branch
BranchTrueFalseTotal
if scalar_is_boolean($data) 4 2415 2419
151 2415 ▶ return $self->deduce_floatlike if scalar_is_float($data);
Branch: 1 branch
BranchTrueFalseTotal
if scalar_is_float($data) 7 2408 2415
152 2408 ▶ return $self->deduce_numberlike if scalar_is_numeric($data);
Branch: 1 branch
BranchTrueFalseTotal
if scalar_is_numeric($data) 2382 26 2408
153 26 return $self->deduce_stringlike;
154 }
155  
156 7 ▶sub deduce_floatlike {
Subroutine deduce_floatlike: called CC=1 SCAR=0.0
Pod undocumented
157 7 my ($self) = @_;
158  
159 7 my $data = $self->get;
160  
161 7 return $self->into_float;
162 }
163  
164 2382 ▶sub deduce_numberlike {
Subroutine deduce_numberlike: called CC=1 SCAR=0.0
Pod undocumented
165 2382 my ($self) = @_;
166  
167 2382 my $data = $self->get;
168  
169 2382 return $self->into_number;
170 }
171  
172 62 ▶sub deduce_references {
Subroutine deduce_references: called CC=4 SCAR=13.9
Pod undocumented
173 62 my ($self) = @_;
174  
175 62 my $data = $self->get;
176  
177 62 ▶ return $self->into_array if ref($data) eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $data eq "ARRAY" 33 29 62
178 29 ▶ return $self->into_code if ref($data) eq 'CODE';
Branch: 1 branch
BranchTrueFalseTotal
if ref $data eq "CODE" 0 29 29
179 29 ▶ return $self->into_hash if ref($data) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $data eq "HASH" 26 3 29
180 3 return $self->into_scalar; # glob, etc
181 }
182  
183 26 ▶sub deduce_stringlike {
Subroutine deduce_stringlike: called CC=1 SCAR=0.0
Pod undocumented
184 26 my ($self) = @_;
185  
186 26 my $data = $self->get;
187  
188 26 return $self->into_string;
189 }
190  
191 1 ▶sub default {
Subroutine default: called CC=1 SCAR=0.0
Pod undocumented
192  
193 1 return undef;
194 }
195  
196 3470 ▶sub detract {
Subroutine detract: called CC=3 SCAR=12.0
Pod documented
197 3470 my ($self) = @_;
198  
199 3470 my $data = $self->get;
200  
201 3470 ▶ return $data if not(scalar_is_blessed($data));
Branch: 1 branch
BranchTrueFalseTotal
unless scalar_is_blessed($data) 0 3470 3470
202  
203 3470 ▶ return $data->value if UNIVERSAL::isa($data, 'Venus::Kind');
Branch: 1 branch
BranchTrueFalseTotal
if UNIVERSAL::isa($data, "Venus::Kind") 3470 0 3470
204  
205 0 return $data;
206 }
207  
208 8 ▶sub detract_deep {
Subroutine detract_deep: called CC=11 SCAR=24.1
Pod documented
209 8 my ($self) = @_;
210  
211 8 my $data = $self->detract;
212  
213 8 ▶ if ($data and ref($data) and ref($data) eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if ($data and ref $data and ref $data eq "HASH") 1 7 8
Condition83%5/6
$data and ref $data and ref $data eq "HASH"
!ll&&!rl&&r
611
$data and ref $data
!ll&&!rl&&r
062
MC/DC66%2/3
$data and ref $data and ref $data eq "HASH"
$data ref $data ref $data eq "HASH"
Truth table75%3/4
A and B and C
A= $dataB= ref $dataC= ref $data eq "HASH"
ABCresult
0XX0
10X0
1100
1111
214 1 for my $i (keys %{$data}) {
215 2 my $val = $data->{$i};
216 2 ▶ $data->{$i} = scalar_is_blessed($val)
Branch: 1 branch
BranchTrueFalseTotal
scalar_is_blessed($val) ? : 2 0 2
217 ? $self->class->new(value => $val)->detract_deep
218 : $self->class->new(value => $val)->detract;
219 }
220 }
221 8 ▶ if ($data and ref($data) and ref($data) eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if ($data and ref $data and ref $data eq "ARRAY") 1 7 8
Condition83%5/6
$data and ref $data and ref $data eq "ARRAY"
!ll&&!rl&&r
611
$data and ref $data
!ll&&!rl&&r
062
MC/DC66%2/3
$data and ref $data and ref $data eq "ARRAY"
$data ref $data ref $data eq "ARRAY"
Truth table75%3/4
A and B and C
A= $dataB= ref $dataC= ref $data eq "ARRAY"
ABCresult
0XX0
10X0
1100
1111
222 1 ▶ for (my $i = 0; $i < @{$data}; $i++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < @{$data;}) 4 1 5
223 4 my $val = $data->[$i];
224 4 ▶ $data->[$i] = scalar_is_blessed($val)
Branch: 1 branch
BranchTrueFalseTotal
scalar_is_blessed($val) ? : 4 0 4
225 ? $self->class->new(value => $val)->detract_deep
226 : $self->class->new(value => $val)->detract;
227 }
228 }
229  
230 8 return $data;
231 }
232  
233 1 ▶sub from_array_to_array {
Subroutine from_array_to_array: called CC=1 SCAR=0.0
Pod undocumented
234 1 my ($self, $data) = @_;
235  
236 1 return $self->into_array($data);
237 }
238  
239 1 ▶sub from_array_to_boolean {
Subroutine from_array_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
240 1 my ($self, $data) = @_;
241  
242 1 return $self->into_boolean(1);
243 }
244  
245 1 ▶sub from_array_to_code {
Subroutine from_array_to_code: called CC=1 SCAR=0.0
Pod undocumented
246 1 my ($self, $data) = @_;
247  
248 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
249 }
250  
251 1 ▶sub from_array_to_float {
Subroutine from_array_to_float: called CC=1 SCAR=0.0
Pod undocumented
252 1 my ($self, $data) = @_;
253  
254 1 return $self->into_float(join('.', map int, !!$data, 0));
255 }
256  
257 1 ▶sub from_array_to_hash {
Subroutine from_array_to_hash: called CC=1 SCAR=0.0
Pod undocumented
258 1 my ($self, $data) = @_;
259  
260 1 return $self->into_hash({map +($_, $data->[$_]), 0..$#$data});
261 }
262  
263 1 ▶sub from_array_to_number {
Subroutine from_array_to_number: called CC=1 SCAR=0.0
Pod undocumented
264 1 my ($self, $data) = @_;
265  
266 1 return $self->into_number(length($self->dump('value')));
267 }
268  
269 1 ▶sub from_array_to_regexp {
Subroutine from_array_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
270 1 my ($self, $data) = @_;
271  
272 1 return $self->into_regexp(qr{@{[quotemeta($self->dump('value'))]}});
273 }
274  
275 1 ▶sub from_array_to_scalar {
Subroutine from_array_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
276 1 my ($self, $data) = @_;
277  
278 1 return $self->into_scalar(\$data);
279 }
280  
281 1 ▶sub from_array_to_string {
Subroutine from_array_to_string: called CC=1 SCAR=0.0
Pod undocumented
282 1 my ($self, $data) = @_;
283  
284 1 return $self->into_string($self->dump('value'));
285 }
286  
287 1 ▶sub from_array_to_undef {
Subroutine from_array_to_undef: called CC=1 SCAR=0.0
Pod undocumented
288 1 my ($self, $data) = @_;
289  
290 1 return $self->into_undef($data);
291 }
292  
293 1 ▶sub from_boolean_to_array {
Subroutine from_boolean_to_array: called CC=1 SCAR=0.0
Pod undocumented
294 1 my ($self, $data) = @_;
295  
296 1 return $self->into_array([$data]);
297 }
298  
299 1 ▶sub from_boolean_to_boolean {
Subroutine from_boolean_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
300 1 my ($self, $data) = @_;
301  
302 1 return $self->into_boolean($data);
303 }
304  
305 1 ▶sub from_boolean_to_code {
Subroutine from_boolean_to_code: called CC=1 SCAR=0.0
Pod undocumented
306 1 my ($self, $data) = @_;
307  
308 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
309 }
310  
311 1 ▶sub from_boolean_to_float {
Subroutine from_boolean_to_float: called CC=1 SCAR=0.0
Pod undocumented
312 1 my ($self, $data) = @_;
313  
314 1 return $self->into_float(join('.', map int, !!$data, 0));
315 }
316  
317 1 ▶sub from_boolean_to_hash {
Subroutine from_boolean_to_hash: called CC=1 SCAR=0.0
Pod undocumented
318 1 my ($self, $data) = @_;
319  
320 1 return $self->into_hash({$data, $data});
321 }
322  
323 1 ▶sub from_boolean_to_number {
Subroutine from_boolean_to_number: called CC=1 SCAR=0.0
Pod undocumented
324 1 my ($self, $data) = @_;
325  
326 1 return $self->into_number(0+!!$data);
327 }
328  
329 1 ▶sub from_boolean_to_regexp {
Subroutine from_boolean_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
330 1 my ($self, $data) = @_;
331  
332 1 return $self->into_regexp(qr{@{[$self->dump('value')]}});
333 }
334  
335 1 ▶sub from_boolean_to_scalar {
Subroutine from_boolean_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
336 1 my ($self, $data) = @_;
337  
338 1 return $self->into_scalar(\$data);
339 }
340  
341 1 ▶sub from_boolean_to_string {
Subroutine from_boolean_to_string: called CC=1 SCAR=0.0
Pod undocumented
342 1 my ($self, $data) = @_;
343  
344 1 return $self->into_string($self->dump('value'));
345 }
346  
347 1 ▶sub from_boolean_to_undef {
Subroutine from_boolean_to_undef: called CC=1 SCAR=0.0
Pod undocumented
348 1 my ($self, $data) = @_;
349  
350 1 return $self->into_undef($data);
351 }
352  
353 1 ▶sub from_code_to_array {
Subroutine from_code_to_array: called CC=1 SCAR=0.0
Pod undocumented
354 1 my ($self, $data) = @_;
355  
356 1 return $self->into_array([$data]);
357 }
358  
359 1 ▶sub from_code_to_boolean {
Subroutine from_code_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
360 1 my ($self, $data) = @_;
361  
362 1 return $self->into_boolean(1);
363 }
364  
365 1 ▶sub from_code_to_code {
Subroutine from_code_to_code: called CC=1 SCAR=0.0
Pod undocumented
366 1 my ($self, $data) = @_;
367  
368 1 return $self->into_code($data);
369 }
370  
371 1 ▶sub from_code_to_float {
Subroutine from_code_to_float: called CC=1 SCAR=0.0
Pod undocumented
372 1 my ($self, $data) = @_;
373  
374 1 return $self->into_float(join('.', map int, !!$data, 0));
375 }
376  
377 1 ▶sub from_code_to_hash {
Subroutine from_code_to_hash: called CC=1 SCAR=0.0
Pod undocumented
378 1 my ($self, $data) = @_;
379  
380 1 return $self->into_hash({0, $data});
381 }
382  
383 1 ▶sub from_code_to_number {
Subroutine from_code_to_number: called CC=1 SCAR=0.0
Pod undocumented
384 1 my ($self, $data) = @_;
385  
386 1 return $self->into_number(length($self->dump('value')));
387 }
388  
389 1 ▶sub from_code_to_regexp {
Subroutine from_code_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
390 1 my ($self, $data) = @_;
391  
392 1 return $self->into_regexp(qr{@{[quotemeta($self->dump('value'))]}});
393 }
394  
395 1 ▶sub from_code_to_scalar {
Subroutine from_code_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
396 1 my ($self, $data) = @_;
397  
398 1 return $self->into_scalar(\$data);
399 }
400  
401 1 ▶sub from_code_to_string {
Subroutine from_code_to_string: called CC=1 SCAR=0.0
Pod undocumented
402 1 my ($self, $data) = @_;
403  
404 1 return $self->into_string($self->dump('value'));
405 }
406  
407 1 ▶sub from_code_to_undef {
Subroutine from_code_to_undef: called CC=1 SCAR=0.0
Pod undocumented
408 1 my ($self, $data) = @_;
409  
410 1 return $self->into_undef($data);
411 }
412  
413 2 ▶sub from_float_to_array {
Subroutine from_float_to_array: called CC=1 SCAR=0.0
Pod undocumented
414 2 my ($self, $data) = @_;
415  
416 2 return $self->into_array([$data]);
417 }
418  
419 1 ▶sub from_float_to_boolean {
Subroutine from_float_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
420 1 my ($self, $data) = @_;
421  
422 1 return $self->into_boolean($data);
423 }
424  
425 1 ▶sub from_float_to_code {
Subroutine from_float_to_code: called CC=1 SCAR=0.0
Pod undocumented
426 1 my ($self, $data) = @_;
427  
428 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
429 }
430  
431 2 ▶sub from_float_to_float {
Subroutine from_float_to_float: called CC=1 SCAR=0.0
Pod undocumented
432 2 my ($self, $data) = @_;
433  
434 2 return $self->into_float($data);
435 }
436  
437 2 ▶sub from_float_to_hash {
Subroutine from_float_to_hash: called CC=1 SCAR=0.0
Pod undocumented
438 2 my ($self, $data) = @_;
439  
440 2 return $self->into_hash({$data, $data});
441 }
442  
443 1 ▶sub from_float_to_number {
Subroutine from_float_to_number: called CC=1 SCAR=0.0
Pod undocumented
444 1 my ($self, $data) = @_;
445  
446 1 return $self->into_number(0+$data);
447 }
448  
449 1 ▶sub from_float_to_regexp {
Subroutine from_float_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
450 1 my ($self, $data) = @_;
451  
452 1 return $self->into_regexp(qr{@{[quotemeta($self->dump('value'))]}});
453 }
454  
455 2 ▶sub from_float_to_scalar {
Subroutine from_float_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
456 2 my ($self, $data) = @_;
457  
458 2 return $self->into_scalar(\$data);
459 }
460  
461 3 ▶sub from_float_to_string {
Subroutine from_float_to_string: called CC=1 SCAR=0.0
Pod undocumented
462 3 my ($self, $data) = @_;
463  
464 3 return $self->into_string($self->dump('value'));
465 }
466  
467 1 ▶sub from_float_to_undef {
Subroutine from_float_to_undef: called CC=1 SCAR=0.0
Pod undocumented
468 1 my ($self, $data) = @_;
469  
470 1 return $self->into_undef($data);
471 }
472  
473 1 ▶sub from_hash_to_array {
Subroutine from_hash_to_array: called CC=1 SCAR=0.0
Pod undocumented
474 1 my ($self, $data) = @_;
475  
476 1 return $self->into_array([$data]);
477 }
478  
479 1 ▶sub from_hash_to_boolean {
Subroutine from_hash_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
480 1 my ($self, $data) = @_;
481  
482 1 return $self->into_boolean(1);
483 }
484  
485 1 ▶sub from_hash_to_code {
Subroutine from_hash_to_code: called CC=1 SCAR=0.0
Pod undocumented
486 1 my ($self, $data) = @_;
487  
488 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
489 }
490  
491 1 ▶sub from_hash_to_float {
Subroutine from_hash_to_float: called CC=1 SCAR=0.0
Pod undocumented
492 1 my ($self, $data) = @_;
493  
494 1 return $self->into_float(join('.', map int, !!$data, 0));
495 }
496  
497 1 ▶sub from_hash_to_hash {
Subroutine from_hash_to_hash: called CC=1 SCAR=0.0
Pod undocumented
498 1 my ($self, $data) = @_;
499  
500 1 return $self->into_hash($data);
501 }
502  
503 1 ▶sub from_hash_to_number {
Subroutine from_hash_to_number: called CC=1 SCAR=0.0
Pod undocumented
504 1 my ($self, $data) = @_;
505  
506 1 return $self->into_number(length($self->dump('value')));
507 }
508  
509 1 ▶sub from_hash_to_regexp {
Subroutine from_hash_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
510 1 my ($self, $data) = @_;
511  
512 1 return $self->into_regexp(qr{@{[quotemeta($self->dump('value'))]}});
513 }
514  
515 1 ▶sub from_hash_to_scalar {
Subroutine from_hash_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
516 1 my ($self, $data) = @_;
517  
518 1 return $self->into_scalar(\$data);
519 }
520  
521 1 ▶sub from_hash_to_string {
Subroutine from_hash_to_string: called CC=1 SCAR=0.0
Pod undocumented
522 1 my ($self, $data) = @_;
523  
524 1 return $self->into_string($self->dump('value'));
525 }
526  
527 1 ▶sub from_hash_to_undef {
Subroutine from_hash_to_undef: called CC=1 SCAR=0.0
Pod undocumented
528 1 my ($self, $data) = @_;
529  
530 1 return $self->into_undef($data);
531 }
532  
533 1 ▶sub from_number_to_array {
Subroutine from_number_to_array: called CC=1 SCAR=0.0
Pod undocumented
534 1 my ($self, $data) = @_;
535  
536 1 return $self->into_array([$data]);
537 }
538  
539 1 ▶sub from_number_to_boolean {
Subroutine from_number_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
540 1 my ($self, $data) = @_;
541  
542 1 return $self->into_boolean(!!$data);
543 }
544  
545 1 ▶sub from_number_to_code {
Subroutine from_number_to_code: called CC=1 SCAR=0.0
Pod undocumented
546 1 my ($self, $data) = @_;
547  
548 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
549 }
550  
551 1 ▶sub from_number_to_float {
Subroutine from_number_to_float: called CC=1 SCAR=0.0
Pod undocumented
552 1 my ($self, $data) = @_;
553  
554 1 return $self->into_float(join('.', map int, (split(/\./, "${data}.0"))[0,1]));
555 }
556  
557 1 ▶sub from_number_to_hash {
Subroutine from_number_to_hash: called CC=1 SCAR=0.0
Pod undocumented
558 1 my ($self, $data) = @_;
559  
560 1 return $self->into_hash({$data, $data});
561 }
562  
563 1 ▶sub from_number_to_number {
Subroutine from_number_to_number: called CC=1 SCAR=0.0
Pod undocumented
564 1 my ($self, $data) = @_;
565  
566 1 return $self->into_number($data);
567 }
568  
569 1 ▶sub from_number_to_regexp {
Subroutine from_number_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
570 1 my ($self, $data) = @_;
571  
572 1 return $self->into_regexp(qr{@{[quotemeta($self->dump('value'))]}});
573 }
574  
575 2 ▶sub from_number_to_scalar {
Subroutine from_number_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
576 2 my ($self, $data) = @_;
577  
578 2 return $self->into_scalar(\$data);
579 }
580  
581 3 ▶sub from_number_to_string {
Subroutine from_number_to_string: called CC=1 SCAR=0.0
Pod undocumented
582 3 my ($self, $data) = @_;
583  
584 3 return $self->into_string($self->dump('value'));
585 }
586  
587 1 ▶sub from_number_to_undef {
Subroutine from_number_to_undef: called CC=1 SCAR=0.0
Pod undocumented
588 1 my ($self, $data) = @_;
589  
590 1 return $self->into_undef($data);
591 }
592  
593 1 ▶sub from_regexp_to_array {
Subroutine from_regexp_to_array: called CC=1 SCAR=0.0
Pod undocumented
594 1 my ($self, $data) = @_;
595  
596 1 return $self->into_array([$data]);
597 }
598  
599 1 ▶sub from_regexp_to_boolean {
Subroutine from_regexp_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
600 1 my ($self, $data) = @_;
601  
602 1 return $self->into_boolean($data);
603 }
604  
605 1 ▶sub from_regexp_to_code {
Subroutine from_regexp_to_code: called CC=1 SCAR=0.0
Pod undocumented
606 1 my ($self, $data) = @_;
607  
608 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
609 }
610  
611 1 ▶sub from_regexp_to_float {
Subroutine from_regexp_to_float: called CC=1 SCAR=0.0
Pod undocumented
612 1 my ($self, $data) = @_;
613  
614 1 return $self->into_float(join('.', map int, !!$data, 0));
615 }
616  
617 1 ▶sub from_regexp_to_hash {
Subroutine from_regexp_to_hash: called CC=1 SCAR=0.0
Pod undocumented
618 1 my ($self, $data) = @_;
619  
620 1 return $self->into_hash({0, $data});
621 }
622  
623 1 ▶sub from_regexp_to_number {
Subroutine from_regexp_to_number: called CC=1 SCAR=0.0
Pod undocumented
624 1 my ($self, $data) = @_;
625  
626 1 return $self->into_number(length($self->dump('value')));
627 }
628  
629 1 ▶sub from_regexp_to_regexp {
Subroutine from_regexp_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
630 1 my ($self, $data) = @_;
631  
632 1 return $self->into_regexp($data);
633 }
634  
635 1 ▶sub from_regexp_to_scalar {
Subroutine from_regexp_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
636 1 my ($self, $data) = @_;
637  
638 1 return $self->into_scalar(\$data);
639 }
640  
641 1 ▶sub from_regexp_to_string {
Subroutine from_regexp_to_string: called CC=1 SCAR=0.0
Pod undocumented
642 1 my ($self, $data) = @_;
643  
644 1 return $self->into_string($self->dump('value'));
645 }
646  
647 1 ▶sub from_regexp_to_undef {
Subroutine from_regexp_to_undef: called CC=1 SCAR=0.0
Pod undocumented
648 1 my ($self, $data) = @_;
649  
650 1 return $self->into_undef($data);
651 }
652  
653 1 ▶sub from_scalar_to_array {
Subroutine from_scalar_to_array: called CC=1 SCAR=0.0
Pod undocumented
654 1 my ($self, $data) = @_;
655  
656 1 return $self->into_array([$data]);
657 }
658  
659 1 ▶sub from_scalar_to_boolean {
Subroutine from_scalar_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
660 1 my ($self, $data) = @_;
661  
662 1 return $self->into_boolean(1);
663 }
664  
665 1 ▶sub from_scalar_to_code {
Subroutine from_scalar_to_code: called CC=1 SCAR=0.0
Pod undocumented
666 1 my ($self, $data) = @_;
667  
668 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
669 }
670  
671 1 ▶sub from_scalar_to_float {
Subroutine from_scalar_to_float: called CC=1 SCAR=0.0
Pod undocumented
672 1 my ($self, $data) = @_;
673  
674 1 return $self->into_float(join('.', map int, !!$data, 0));
675 }
676  
677 1 ▶sub from_scalar_to_hash {
Subroutine from_scalar_to_hash: called CC=1 SCAR=0.0
Pod undocumented
678 1 my ($self, $data) = @_;
679  
680 1 return $self->into_hash({0, $data});
681 }
682  
683 1 ▶sub from_scalar_to_number {
Subroutine from_scalar_to_number: called CC=1 SCAR=0.0
Pod undocumented
684 1 my ($self, $data) = @_;
685  
686 1 return $self->into_number(length($self->dump('value')));
687 }
688  
689 1 ▶sub from_scalar_to_regexp {
Subroutine from_scalar_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
690 1 my ($self, $data) = @_;
691  
692 1 return $self->into_regexp(qr{@{[quotemeta($self->dump('value'))]}});
693 }
694  
695 1 ▶sub from_scalar_to_scalar {
Subroutine from_scalar_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
696 1 my ($self, $data) = @_;
697  
698 1 return $self->into_scalar($data);
699 }
700  
701 1 ▶sub from_scalar_to_string {
Subroutine from_scalar_to_string: called CC=1 SCAR=0.0
Pod undocumented
702 1 my ($self, $data) = @_;
703  
704 1 return $self->into_string($self->dump('value'));
705 }
706  
707 1 ▶sub from_scalar_to_undef {
Subroutine from_scalar_to_undef: called CC=1 SCAR=0.0
Pod undocumented
708 1 my ($self, $data) = @_;
709  
710 1 return $self->into_undef($data);
711 }
712  
713 1 ▶sub from_string_to_array {
Subroutine from_string_to_array: called CC=1 SCAR=0.0
Pod undocumented
714 1 my ($self, $data) = @_;
715  
716 1 return $self->into_array([$data]);
717 }
718  
719 1 ▶sub from_string_to_boolean {
Subroutine from_string_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
720 1 my ($self, $data) = @_;
721  
722 1 return $self->into_boolean(!!$data);
723 }
724  
725 1 ▶sub from_string_to_code {
Subroutine from_string_to_code: called CC=1 SCAR=0.0
Pod undocumented
726 1 my ($self, $data) = @_;
727  
728 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
729 }
730  
731 1 ▶sub from_string_to_float {
Subroutine from_string_to_float: called CC=2 SCAR=7.1
Pod undocumented
732 1 my ($self, $data) = @_;
733  
734 1 require Scalar::Util;
735  
736 1 ▶ return $self->into_float(join('.',
Branch: 1 branch
BranchTrueFalseTotal
&Scalar::Util::looks_like_number($data) ? : 0 1 1
737 Scalar::Util::looks_like_number($data) ? (split(/\./, "$data.0"))[0,1] : (0,0))
738 );
739 }
740  
741 1 ▶sub from_string_to_hash {
Subroutine from_string_to_hash: called CC=1 SCAR=0.0
Pod undocumented
742 1 my ($self, $data) = @_;
743  
744 1 return $self->into_hash({$data, $data});
745 }
746  
747 1 ▶sub from_string_to_number {
Subroutine from_string_to_number: called CC=2 SCAR=7.1
Pod undocumented
748 1 my ($self, $data) = @_;
749  
750 1 require Scalar::Util;
751  
752 1 ▶ return $self->into_number(Scalar::Util::looks_like_number($data) ? 0+$data : 0);
Branch: 1 branch
BranchTrueFalseTotal
&Scalar::Util::looks_like_number($data) ? : 0 1 1
753 }
754  
755 1 ▶sub from_string_to_regexp {
Subroutine from_string_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
756 1 my ($self, $data) = @_;
757  
758 1 return $self->into_regexp(qr{@{[$self->dump('value')]}});
759 }
760  
761 2 ▶sub from_string_to_scalar {
Subroutine from_string_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
762 2 my ($self, $data) = @_;
763  
764 2 return $self->into_scalar(\$data);
765 }
766  
767 4 ▶sub from_string_to_string {
Subroutine from_string_to_string: called CC=1 SCAR=0.0
Pod undocumented
768 4 my ($self, $data) = @_;
769  
770 4 return $self->into_string($self->dump('value'));
771 }
772  
773 1 ▶sub from_string_to_undef {
Subroutine from_string_to_undef: called CC=1 SCAR=0.0
Pod undocumented
774 1 my ($self, $data) = @_;
775  
776 1 return $self->into_undef($data);
777 }
778  
779 1 ▶sub from_undef_to_array {
Subroutine from_undef_to_array: called CC=1 SCAR=0.0
Pod undocumented
780 1 my ($self, $data) = @_;
781  
782 1 return $self->into_array([$data]);
783 }
784  
785 1 ▶sub from_undef_to_boolean {
Subroutine from_undef_to_boolean: called CC=1 SCAR=0.0
Pod undocumented
786 1 my ($self, $data) = @_;
787  
788 1 return $self->into_boolean(0);
789 }
790  
791 1 ▶sub from_undef_to_code {
Subroutine from_undef_to_code: called CC=1 SCAR=0.0
Pod undocumented
792 1 my ($self, $data) = @_;
793  
794 1 ▶ return $self->into_code(sub{$data});
Subroutine __ANON__: called CC=1 SCAR=0.0
795 }
796  
797 1 ▶sub from_undef_to_float {
Subroutine from_undef_to_float: called CC=1 SCAR=0.0
Pod undocumented
798 1 my ($self, $data) = @_;
799  
800 1 return $self->into_float('0.0');
801 }
802  
803 1 ▶sub from_undef_to_hash {
Subroutine from_undef_to_hash: called CC=1 SCAR=0.0
Pod undocumented
804 1 my ($self, $data) = @_;
805  
806 1 return $self->into_hash({});
807 }
808  
809 1 ▶sub from_undef_to_number {
Subroutine from_undef_to_number: called CC=1 SCAR=0.0
Pod undocumented
810 1 my ($self, $data) = @_;
811  
812 1 return $self->into_number(0);
813 }
814  
815 1 ▶sub from_undef_to_regexp {
Subroutine from_undef_to_regexp: called CC=1 SCAR=0.0
Pod undocumented
816 1 my ($self, $data) = @_;
817  
818 1 return $self->into_regexp(qr//);
819 }
820  
821 1 ▶sub from_undef_to_scalar {
Subroutine from_undef_to_scalar: called CC=1 SCAR=0.0
Pod undocumented
822 1 my ($self, $data) = @_;
823  
824 1 return $self->into_scalar(\'');
825 }
826  
827 1 ▶sub from_undef_to_string {
Subroutine from_undef_to_string: called CC=1 SCAR=0.0
Pod undocumented
828 1 my ($self, $data) = @_;
829  
830 1 return $self->into_string('');
831 }
832  
833 2 ▶sub from_undef_to_undef {
Subroutine from_undef_to_undef: called CC=1 SCAR=0.0
Pod undocumented
834 2 my ($self, $data) = @_;
835  
836 2 return $self->into_undef($data);
837 }
838  
839 1375 ▶sub identify {
Subroutine identify: called CC=12 SCAR=24.8
Pod documented
840 1375 my ($self) = @_;
841  
842 1375 my $data = $self->get;
843  
844 1375 my $defined = true;
845 1375 my $blessed = false;
846  
847 1375 my $type_name;
848  
849 1375 ▶ if (not(defined($data))) {
Branch: 6 branches
BranchTrueFalseTotal
if (not defined $data) { } 80 1295 1375
elsif (scalar_is_blessed($data)) { } 174 1121 1295
elsif (ref $data) { } 310 811 1121
elsif (scalar_is_boolean($data)) { } 28 783 811
elsif (scalar_is_float($data)) { } 121 662 783
elsif (scalar_is_numeric($data)) { } 305 357 662
850 80 $type_name = 'UNDEF';
851 80 $defined = false;
852 }
853 elsif (scalar_is_blessed($data)) {
854 174 ▶ $type_name = $data->isa('Regexp') ? 'REGEXP' : 'OBJECT';
Branch: 1 branch
BranchTrueFalseTotal
$data->isa('Regexp') ? : 30 144 174
855 174 $blessed = true;
856 }
857 elsif (ref($data)) {
858 310 ▶ if (ref($data) eq 'ARRAY') {
Branch: 3 branches
BranchTrueFalseTotal
if (ref $data eq 'ARRAY') { } 104 206 310
elsif (ref $data eq 'CODE') { } 33 173 206
elsif (ref $data eq 'HASH') { } 113 60 173
859 104 $type_name = 'ARRAY';
860 }
861 elsif (ref($data) eq 'CODE') {
862 33 $type_name = 'CODE';
863 }
864 elsif (ref($data) eq 'HASH') {
865 113 $type_name = 'HASH';
866 }
867 else {
868 60 $type_name = 'SCALAR';
869 }
870 }
871 elsif (scalar_is_boolean($data)) {
872 28 $type_name = 'BOOLEAN';
873 }
874 elsif (scalar_is_float($data)) {
875 121 $type_name = 'FLOAT';
876 }
877 elsif (scalar_is_numeric($data)) {
878 305 $type_name = 'NUMBER';
879 }
880 else {
881 357 $type_name = 'STRING';
882 }
883  
884 1375 ▶ return wantarray ? ($defined, $blessed, $type_name) : $type_name;
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 4 1371 1375
885 }
886  
887 44 ▶sub into_array {
Subroutine into_array: called CC=2 SCAR=6.9
Pod undocumented
888 44 my ($self, $data) = @_;
889  
890 44 ▶ $data = [@{$self->get}] if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 33 11 44
891  
892 44 require Venus::Array;
893  
894 44 return Venus::Array->new($data);
895 }
896  
897 14 ▶sub into_boolean {
Subroutine into_boolean: called CC=2 SCAR=6.9
Pod undocumented
898 14 my ($self, $data) = @_;
899  
900 14 ▶ $data = $self->get if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 4 10 14
901  
902 14 require Venus::Boolean;
903  
904 14 return Venus::Boolean->new($data);
905 }
906  
907 10 ▶sub into_code {
Subroutine into_code: called CC=2 SCAR=7.0
Pod undocumented
908 10 my ($self, $data) = @_;
909  
910 10 ▶ $data = $self->get if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 0 10 10
911  
912 10 require Venus::Code;
913  
914 10 return Venus::Code->new($data);
915 }
916  
917 18 ▶sub into_float {
Subroutine into_float: called CC=2 SCAR=6.9
Pod undocumented
918 18 my ($self, $data) = @_;
919  
920 18 ▶ $data = $self->get if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 7 11 18
921  
922 18 require Venus::Float;
923  
924 18 return Venus::Float->new($data);
925 }
926  
927 37 ▶sub into_hash {
Subroutine into_hash: called CC=2 SCAR=6.9
Pod undocumented
928 37 my ($self, $data) = @_;
929  
930 37 ▶ $data = {%{$self->get}} if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 26 11 37
931  
932 37 require Venus::Hash;
933  
934 37 return Venus::Hash->new($data);
935 }
936  
937 2392 ▶sub into_number {
Subroutine into_number: called CC=2 SCAR=6.9
Pod undocumented
938 2392 my ($self, $data) = @_;
939  
940 2392 ▶ $data = $self->get if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 2382 10 2392
941  
942 2392 require Venus::Number;
943  
944 2392 return Venus::Number->new($data);
945 }
946  
947 13 ▶sub into_regexp {
Subroutine into_regexp: called CC=2 SCAR=6.9
Pod undocumented
948 13 my ($self, $data) = @_;
949  
950 13 ▶ $data = $self->get if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 3 10 13
951  
952 13 require Venus::Regexp;
953  
954 13 return Venus::Regexp->new($data);
955 }
956  
957 16 ▶sub into_scalar {
Subroutine into_scalar: called CC=2 SCAR=6.9
Pod undocumented
958 16 my ($self, $data) = @_;
959  
960 16 ▶ $data = $self->get if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 3 13 16
961  
962 16 require Venus::Scalar;
963  
964 16 return Venus::Scalar->new($data);
965 }
966  
967 43 ▶sub into_string {
Subroutine into_string: called CC=2 SCAR=6.9
Pod undocumented
968 43 my ($self, $data) = @_;
969  
970 43 ▶ $data = $self->get if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 26 17 43
971  
972 43 require Venus::String;
973  
974 43 return Venus::String->new($data);
975 }
976  
977 138 ▶sub into_undef {
Subroutine into_undef: called CC=2 SCAR=6.9
Pod undocumented
978 138 my ($self, $data) = @_;
979  
980 138 ▶ $data = $self->get if $#_ <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $#_ <= 0 127 11 138
981  
982 138 require Venus::Undef;
983  
984 138 return Venus::Undef->new($data);
985 }
986  
987 2 ▶sub package {
Subroutine package: called CC=1 SCAR=0.0
Pod documented
988 2 my ($self) = @_;
989  
990 2 my $data = $self->deduce;
991  
992 2 return ref($data);
993 }
994  
995 8193 ▶sub scalar_is_blessed {
Subroutine scalar_is_blessed: called CC=1 SCAR=0.0
Pod undocumented
996 8193 my ($value) = @_;
997  
998 8193 return Scalar::Util::blessed($value);
999 }
1000  
1001 3264 ▶sub scalar_is_boolean {
Subroutine scalar_is_boolean: called CC=7 SCAR=20.5
Pod undocumented
1002 3264 my ($value) = @_;
1003  
1004 3264 ▶ return Scalar::Util::isdual($value) && (
Condition72%13/18
&Scalar::Util::isdual($value) && ("$value" eq '' && $value + 0 == 0 || "$value" == 1 && $value + 0 == 1 || "$value" == 0 && $value + 0 == 0)
!ll&&!rl&&r
32201232
"$value" eq "" and $value + 0 == 0 or "$value" == 1 and $value + 0 == 1 or "$value" == 0 and $value + 0 == 0
l!l&&r!l&&!r
151712
"$value" eq "" and $value + 0 == 0 or "$value" == 1 and $value + 0 == 1
l!l&&r!l&&!r
01529
"$value" eq "" and $value + 0 == 0
!ll&&!rl&&r
4400
"$value" == 1 and $value + 0 == 1
!ll&&!rl&&r
29015
"$value" == 0 and $value + 0 == 0
!ll&&!rl&&r
12017
MC/DC42%3/7
&Scalar::Util::isdual($value) && ("$value" eq '' && $value + 0 == 0 || "$value" == 1 && $value + 0 == 1 || "$value" == 0 && $value + 0 == 0)
&Scalar::Util::isdual($value) "$value" eq "" $value + 0 == 0 "$value" == 1 $value + 0 == 1 "$value" == 0 $value + 0 == 0
Truth table25%4/16
A && B and C or D and E or F and G
A= &Scalar::Util::isdual($value)B= "$value" eq ""C= $value + 0 == 0D= "$value" == 1E= $value + 0 == 1F= "$value" == 0G= $value + 0 == 0
ABCDEFGresult
0XXXXXX0
10X0X0X0
10X0X100
10X100X0
10X10100
1100X0X0
1100X100
110100X0
11010100
111XXXX1
10X11XX1
11011XX1
10X0X111
10X10111
1100X111
11010111
1005 ("$value" eq "" && ($value + 0) == 0) || # support !!0
1006 ("$value" == "1" && ($value + 0) == 1) ||
1007 ("$value" == "0" && ($value + 0) == 0)
1008 );
1009 }
1010  
1011 3198 ▶sub scalar_is_float {
Subroutine scalar_is_float: called CC=2 SCAR=6.9
Pod undocumented
1012 3198 my ($value) = @_;
1013  
1014 3198 ▶ return Scalar::Util::looks_like_number($value) && length(do{
Condition100%3/3
&Scalar::Util::looks_like_number($value) && length do { $value =~ /^[+-]?([0-9]*\.[0-9]+)([eE][+-]?[0-9]+)?$/u }
!ll&&!rl&&r
3612709128
MC/DC100%2/2
&Scalar::Util::looks_like_number($value) && length do { $value =~ /^[+-]?([0-9]*\.[0-9]+)([eE][+-]?[0-9]+)?$/u }
&Scalar::Util::looks_like_number($value) length do { $value =~ /^[+-]?([0-9]*\.[0-9]+)([eE][+-]?[0-9]+)?$/u }
Truth table100%3/3
A && B
A= &Scalar::Util::looks_like_number($value)B= length do { $value =~ /^[+-]?([0-9]*\.[0-9]+)([eE][+-]?[0-9]+)?$/u }
ABresult
0X0
100
111
1015 2837 $value =~ /^[+-]?([0-9]*\.[0-9]+)([eE][+-]?[0-9]+)?$/;
1016 });
1017 }
1018  
1019 3142 ▶sub scalar_is_numeric {
Subroutine scalar_is_numeric: called CC=2 SCAR=6.9
Pod undocumented
1020 3142 my ($value) = @_;
1021  
1022 3142 ▶ return Scalar::Util::looks_like_number($value) && length(do{
Condition100%3/3
&Scalar::Util::looks_like_number($value) && length do { BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x51\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"} $value & '' }
!ll&&!rl&&r
361312750
MC/DC100%2/2
&Scalar::Util::looks_like_number($value) && length do { BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x51\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"} $value & '' }
&Scalar::Util::looks_like_number($value) length do { BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x51\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"} $value & '' }
Truth table100%3/3
A && B
A= &Scalar::Util::looks_like_number($value)B= length do { BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x51\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"} $value & '' }
ABresult
0X0
100
111
1023 119 ▶ no if $] >= 5.022, "feature", "bitwise";
Subroutine BEGIN: called CC=1 SCAR=0.0
1024 119 ▶ no warnings "numeric";
Subroutine BEGIN: called CC=1 SCAR=0.0
1025 2781 $value & ""
1026 });
1027 }
1028  
1029 119 1;
1030  
1031  
1032  
1033 =head1 NAME
1034  
1035 Venus::What - What Class
1036  
1037 =cut
1038  
1039 =head1 ABSTRACT
1040  
1041 What Class for Perl 5
1042  
1043 =cut
1044  
1045 =head1 SYNOPSIS
1046  
1047 package main;
1048  
1049 use Venus::What;
1050  
1051 my $what = Venus::What->new([]);
1052  
1053 # $what->code;
1054  
1055 =cut
1056  
1057 =head1 DESCRIPTION
1058  
1059 This package provides methods for casting native data types to objects and the
1060 reverse.
1061  
1062 =cut
1063  
1064 =head1 INHERITS
1065  
1066 This package inherits behaviors from:
1067  
1068 L<Venus::Kind::Utility>
1069  
1070 =cut
1071  
1072 =head1 INTEGRATES
1073  
1074 This package integrates behaviors from:
1075  
1076 L<Venus::Role::Accessible>
1077  
1078 L<Venus::Role::Buildable>
1079  
1080 L<Venus::Role::Valuable>
1081  
1082 =cut
1083  
1084 =head1 METHODS
1085  
1086 This package provides the following methods:
1087  
1088 =cut
1089  
1090 =head2 code
1091  
1092 code() (string | undef)
1093  
1094 The code method returns the name of the value's data type.
1095  
1096 I<Since C<0.01>>
1097  
1098 =over 4
1099  
1100 =item code example 1
1101  
1102 # given: synopsis;
1103  
1104 my $code = $what->code;
1105  
1106 # "ARRAY"
1107  
1108 =back
1109  
1110 =over 4
1111  
1112 =item code example 2
1113  
1114 package main;
1115  
1116 use Venus::What;
1117  
1118 my $what = Venus::What->new(value => {});
1119  
1120 my $code = $what->code;
1121  
1122 # "HASH"
1123  
1124 =back
1125  
1126 =over 4
1127  
1128 =item code example 3
1129  
1130 package main;
1131  
1132 use Venus::What;
1133  
1134 my $what = Venus::What->new(value => qr//);
1135  
1136 my $code = $what->code;
1137  
1138 # "REGEXP"
1139  
1140 =back
1141  
1142 =cut
1143  
1144 =head2 coded
1145  
1146 coded(string $code) (boolean)
1147  
1148 The coded method return true or false if the data type name provided matches
1149 the result of L</code>.
1150  
1151 I<Since C<1.23>>
1152  
1153 =over 4
1154  
1155 =item coded example 1
1156  
1157 # given: synopsis;
1158  
1159 my $coded = $what->coded('ARRAY');
1160  
1161 # 1
1162  
1163 =back
1164  
1165 =over 4
1166  
1167 =item coded example 2
1168  
1169 # given: synopsis;
1170  
1171 my $coded = $what->coded('HASH');
1172  
1173 # 0
1174  
1175 =back
1176  
1177 =cut
1178  
1179 =head2 deduce
1180  
1181 deduce() (object)
1182  
1183 The deduce methods returns the argument as a data type object.
1184  
1185 I<Since C<0.01>>
1186  
1187 =over 4
1188  
1189 =item deduce example 1
1190  
1191 # given: synopsis;
1192  
1193 my $deduce = $what->deduce;
1194  
1195 # bless({ value => [] }, "Venus::Array")
1196  
1197 =back
1198  
1199 =over 4
1200  
1201 =item deduce example 2
1202  
1203 package main;
1204  
1205 use Venus::What;
1206  
1207 my $what = Venus::What->new(value => {});
1208  
1209 my $deduce = $what->deduce;
1210  
1211 # bless({ value => {} }, "Venus::Hash")
1212  
1213 =back
1214  
1215 =over 4
1216  
1217 =item deduce example 3
1218  
1219 package main;
1220  
1221 use Venus::What;
1222  
1223 my $what = Venus::What->new(value => qr//);
1224  
1225 my $deduce = $what->deduce;
1226  
1227 # bless({ value => qr// }, "Venus::Regexp")
1228  
1229 =back
1230  
1231 =over 4
1232  
1233 =item deduce example 4
1234  
1235 package main;
1236  
1237 use Venus::What;
1238  
1239 my $what = Venus::What->new(value => '1.23');
1240  
1241 my $deduce = $what->deduce;
1242  
1243 # bless({ value => "1.23" }, "Venus::Float")
1244  
1245 =back
1246  
1247 =cut
1248  
1249 =head2 deduce_deep
1250  
1251 deduce_deep() (object)
1252  
1253 The deduce_deep function returns any arguments as data type objects, including
1254 nested data.
1255  
1256 I<Since C<0.01>>
1257  
1258 =over 4
1259  
1260 =item deduce_deep example 1
1261  
1262 package main;
1263  
1264 use Venus::What;
1265  
1266 my $what = Venus::What->new(value => [1..4]);
1267  
1268 my $deduce_deep = $what->deduce_deep;
1269  
1270 # bless({
1271 # value => [
1272 # bless({ value => 1 }, "Venus::Number"),
1273 # bless({ value => 2 }, "Venus::Number"),
1274 # bless({ value => 3 }, "Venus::Number"),
1275 # bless({ value => 4 }, "Venus::Number"),
1276 # ],
1277 # }, "Venus::Array")
1278  
1279 =back
1280  
1281 =over 4
1282  
1283 =item deduce_deep example 2
1284  
1285 package main;
1286  
1287 use Venus::What;
1288  
1289 my $what = Venus::What->new(value => {1..4});
1290  
1291 my $deduce_deep = $what->deduce_deep;
1292  
1293 # bless({
1294 # value => {
1295 # 1 => bless({ value => 2 }, "Venus::Number"),
1296 # 3 => bless({ value => 4 }, "Venus::Number"),
1297 # },
1298 # }, "Venus::Hash")
1299  
1300 =back
1301  
1302 =cut
1303  
1304 =head2 detract
1305  
1306 detract() (any)
1307  
1308 The detract method returns the argument as native Perl data type value.
1309  
1310 I<Since C<0.01>>
1311  
1312 =over 4
1313  
1314 =item detract example 1
1315  
1316 package main;
1317  
1318 use Venus::What;
1319 use Venus::Hash;
1320  
1321 my $what = Venus::What->new(Venus::Hash->new({1..4}));
1322  
1323 my $detract = $what->detract;
1324  
1325 # { 1 => 2, 3 => 4 }
1326  
1327 =back
1328  
1329 =over 4
1330  
1331 =item detract example 2
1332  
1333 package main;
1334  
1335 use Venus::What;
1336 use Venus::Array;
1337  
1338 my $what = Venus::What->new(Venus::Array->new([1..4]));
1339  
1340 my $detract = $what->detract;
1341  
1342 # [1..4]
1343  
1344 =back
1345  
1346 =over 4
1347  
1348 =item detract example 3
1349  
1350 package main;
1351  
1352 use Venus::What;
1353 use Venus::Regexp;
1354  
1355 my $what = Venus::What->new(Venus::Regexp->new(qr/\w+/));
1356  
1357 my $detract = $what->detract;
1358  
1359 # qr/\w+/
1360  
1361 =back
1362  
1363 =over 4
1364  
1365 =item detract example 4
1366  
1367 package main;
1368  
1369 use Venus::What;
1370 use Venus::Float;
1371  
1372 my $what = Venus::What->new(Venus::Float->new('1.23'));
1373  
1374 my $detract = $what->detract;
1375  
1376 # "1.23"
1377  
1378 =back
1379  
1380 =cut
1381  
1382 =head2 detract_deep
1383  
1384 detract_deep() (any)
1385  
1386 The detract_deep method returns any arguments as native Perl data type values,
1387 including nested data.
1388  
1389 I<Since C<0.01>>
1390  
1391 =over 4
1392  
1393 =item detract_deep example 1
1394  
1395 package main;
1396  
1397 use Venus::What;
1398 use Venus::Hash;
1399  
1400 my $what = Venus::What->new(Venus::Hash->new({1..4}));
1401  
1402 my $detract_deep = Venus::What->new($what->deduce_deep)->detract_deep;
1403  
1404 # { 1 => 2, 3 => 4 }
1405  
1406 =back
1407  
1408 =over 4
1409  
1410 =item detract_deep example 2
1411  
1412 package main;
1413  
1414 use Venus::What;
1415 use Venus::Array;
1416  
1417 my $what = Venus::What->new(Venus::Array->new([1..4]));
1418  
1419 my $detract_deep = Venus::What->new($what->deduce_deep)->detract_deep;
1420  
1421 # [1..4]
1422  
1423 =back
1424  
1425 =cut
1426  
1427 =head2 identify
1428  
1429 identify() (boolean, boolean, string)
1430  
1431 The identify method returns the value's data type, or L</code>, in scalar
1432 context. In list context, this method will return a tuple with (defined,
1433 blessed, and data type) elements. B<Note:> For globs and file handles this
1434 method will return "scalar" as the data type.
1435  
1436 I<Since C<1.23>>
1437  
1438 =over 4
1439  
1440 =item identify example 1
1441  
1442 # given: synopsis
1443  
1444 package main;
1445  
1446 my ($defined, $blessed, $whatname) = $what->identify;
1447  
1448 # (1, 0, 'ARRAY')
1449  
1450 =back
1451  
1452 =over 4
1453  
1454 =item identify example 2
1455  
1456 package main;
1457  
1458 use Venus::What;
1459  
1460 my $what = Venus::What->new(value => {});
1461  
1462 my ($defined, $blessed, $whatname) = $what->identify;
1463  
1464 # (1, 0, 'HASH')
1465  
1466 =back
1467  
1468 =over 4
1469  
1470 =item identify example 3
1471  
1472 package main;
1473  
1474 use Venus::What;
1475  
1476 my $what = Venus::What->new(value => qr//);
1477  
1478 my ($defined, $blessed, $whatname) = $what->identify;
1479  
1480 # (1, 1, 'REGEXP')
1481  
1482 =back
1483  
1484 =over 4
1485  
1486 =item identify example 4
1487  
1488 package main;
1489  
1490 use Venus::What;
1491  
1492 my $what = Venus::What->new(value => bless{});
1493  
1494 my ($defined, $blessed, $whatname) = $what->identify;
1495  
1496 # (1, 1, 'OBJECT')
1497  
1498 =back
1499  
1500 =cut
1501  
1502 =head2 new
1503  
1504 new(any @args) (Venus::What)
1505  
1506 The new method constructs an instance of the package.
1507  
1508 I<Since C<4.15>>
1509  
1510 =over 4
1511  
1512 =item new example 1
1513  
1514 package main;
1515  
1516 use Venus::What;
1517  
1518 my $new = Venus::What->new;
1519  
1520 # bless(..., "Venus::What")
1521  
1522 =back
1523  
1524 =over 4
1525  
1526 =item new example 2
1527  
1528 package main;
1529  
1530 use Venus::What;
1531  
1532 my $new = Venus::What->new('hello world');
1533  
1534 # bless(..., "Venus::What")
1535  
1536 =back
1537  
1538 =over 4
1539  
1540 =item new example 3
1541  
1542 package main;
1543  
1544 use Venus::What;
1545  
1546 my $new = Venus::What->new(value => 'hello world');
1547  
1548 # bless(..., "Venus::What")
1549  
1550 =back
1551  
1552 =cut
1553  
1554 =head2 package
1555  
1556 package() (string)
1557  
1558 The code method returns the package name of the objectified value, i.e.
1559 C<ref()>.
1560  
1561 I<Since C<0.01>>
1562  
1563 =over 4
1564  
1565 =item package example 1
1566  
1567 # given: synopsis;
1568  
1569 my $package = $what->package;
1570  
1571 # "Venus::Array"
1572  
1573 =back
1574  
1575 =over 4
1576  
1577 =item package example 2
1578  
1579 package main;
1580  
1581 use Venus::What;
1582  
1583 my $what = Venus::What->new(value => {});
1584  
1585 my $package = $what->package;
1586  
1587 # "Venus::Hash"
1588  
1589 =back
1590  
1591 =cut
1592  
1593 =head1 AUTHORS
1594  
1595 Awncorp, C<awncorp@cpan.org>
1596  
1597 =cut
1598  
1599 =head1 LICENSE
1600  
1601 Copyright (C) 2022, Awncorp, C<awncorp@cpan.org>.
1602  
1603 This program is free software, you can redistribute it and/or modify it under
1604 the terms of the Apache license version 2.0.
1605  
1606 =cut
« blib/lib/Venus/Search.pm ↑ Summary blib/lib/Venus/Enum.pm »