Modern/Vocabulary/Validation.pm

filter: Statementstmt 99.0% 200 / 202 Branchbran 90.4% 152 / 168 Conditioncond 82.6% 86 / 104 MC/DCmcdc 59.5% 28 / 47 Subroutinesub 100% 53 / 53 Podpod 0.0% 0 / 3 totaltotal 89.9% 519 / 577 CC 126 SCAR 19.1
CC
126
Cov
92%
_eval_keyword_type
16.0
_traverse_keyword_type
12.7
_eval_keyword_multipleOf
11.1
CRAP 6.8
« Modern/Vocabulary/Core.pm ↑ Summary Modern/ResultNode.pm »
1 38 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
2 38 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 package JSON::Schema::Modern::Vocabulary::Validation;
4 # vim: set ts=8 sts=2 sw=2 tw=100 et :
5 # ABSTRACT: Implementation of the JSON Schema Validation vocabulary
6  
7 38 our $VERSION = '0.654';
8  
9 38 ▶use 5.020;
Subroutine BEGIN: called CC=1 SCAR=0.0
10 38 ▶use Moo;
Subroutine BEGIN: called CC=1 SCAR=0.0
11 38 ▶use strictures 2;
Subroutine BEGIN: called CC=1 SCAR=0.0
12 38 ▶use stable 0.031 'postderef';
Subroutine BEGIN: called CC=1 SCAR=0.0
13 38 ▶use experimental 'signatures';
Subroutine BEGIN: called CC=1 SCAR=0.0
14 38 ▶no autovivification warn => qw(fetch store exists delete);
Subroutine BEGIN: called CC=1 SCAR=0.0
15 38 ▶use if "$]" >= 5.022, experimental => 're_strict';
Subroutine BEGIN: called CC=1 SCAR=0.0
16 38 ▶no if "$]" >= 5.031009, feature => 'indirect';
Subroutine BEGIN: called CC=1 SCAR=0.0
17 38 ▶no if "$]" >= 5.033001, feature => 'multidimensional';
Subroutine BEGIN: called CC=1 SCAR=0.0
18 38 ▶no if "$]" >= 5.033006, feature => 'bareword_filehandles';
Subroutine BEGIN: called CC=1 SCAR=0.0
19 38 ▶no if "$]" >= 5.041009, feature => 'smartmatch';
Subroutine BEGIN: called CC=1 SCAR=0.0
20 38 ▶no feature 'switch';
Subroutine BEGIN: called CC=1 SCAR=0.0
21 38 ▶use if "$]" < 5.041010, 'List::Util' => 'any';
Subroutine BEGIN: called CC=1 SCAR=0.0
22 38 ▶use if "$]" >= 5.041010, experimental => 'keyword_any';
Subroutine BEGIN: called CC=1 SCAR=0.0
23 38 ▶use Scalar::Util 'looks_like_number';
Subroutine BEGIN: called CC=1 SCAR=0.0
24 38 ▶use JSON::Schema::Modern::Utilities qw(is_type get_type is_bignum is_equal is_elements_unique E assert_keyword_type assert_pattern jsonp sprintf_num);
Subroutine BEGIN: called CC=1 SCAR=0.0
25 38 ▶use Math::BigFloat;
Subroutine BEGIN: called CC=1 SCAR=0.0
26 38 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
27  
28 38 with 'JSON::Schema::Modern::Vocabulary';
29  
30 22 ▶sub vocabulary ($class) {
Subroutine vocabulary: called CC=1 SCAR=0.0
Pod undocumented
31 22 'https://json-schema.org/draft/2019-09/vocab/validation' => 'draft2019-09',
32 'https://json-schema.org/draft/2020-12/vocab/validation' => 'draft2020-12';
33 }
34  
35 14 ▶sub evaluation_order ($class) { 1 }
Subroutine evaluation_order: called CC=1 SCAR=0.0
Pod undocumented
36  
37 169 ▶sub keywords ($class, $spec_version) {
Subroutine keywords: called CC=4 SCAR=13.9
Pod undocumented
38 return (
39 169 ▶ qw(type enum),
Branch: 3 branches
BranchTrueFalseTotal
$spec_version ne 'draft4' ? : 149 20 169
!($spec_version =~ /^draft[467]\z/u) ? : 105 64 169
!($spec_version =~ /^draft[467]\z/u) ? : 105 64 169
40 $spec_version ne 'draft4' ? 'const' : (),
41 qw(multipleOf maximum exclusiveMaximum minimum exclusiveMinimum
42 maxLength minLength pattern maxItems minItems uniqueItems),
43 $spec_version !~ /^draft[467]\z/ ? qw(maxContains minContains) : (),
44 qw(maxProperties minProperties required),
45 $spec_version !~ /^draft[467]\z/ ? 'dependentRequired' : (),
46 );
47 }
48  
49 8619 ▶sub _traverse_keyword_type ($class, $schema, $state) {
Subroutine _traverse_keyword_type: called CC=12 SCAR=25.4
50 8619 ▶ if (ref $schema->{type} eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $$schema{'type'} eq 'ARRAY') { } 364 8255 8619
51 # Note: this is not actually in the spec, but the restriction exists in the metaschema
52 364 ▶ return E($state, 'type array is empty') if not $schema->{type}->@*;
Branch: 1 branch
BranchTrueFalseTotal
unless @{$$schema{"type"}} 0 364 364
53  
54 364 foreach my $type ($schema->{type}->@*) {
55 return E($state, 'unrecognized type "%s"', $type//'<null>')
56 758 ▶ if not any { ($type//'') eq $_ } qw(null boolean object array string number integer);
Branch: 1 branch
BranchTrueFalseTotal
unless CORE::any {($type // "") eq $_;} "null", "boolean", "object", "array", "string", "number", "integer" 4 754 758
Condition75%3/4
$type // ""
l!l
287828
$type // "<null>"
l!l
04
MC/DC100%1/1
$type // ""
$type
MC/DC0%0/1
$type // "<null>"
$type
Truth table100%2/2
A
A= $type
Aresult
11
00
Truth table50%1/2
A
A= $type
Aresult
11
00
57 }
58 360 ▶ return E($state, '"type" values are not unique') if not is_elements_unique($schema->{type});
Branch: 1 branch
BranchTrueFalseTotal
unless is_elements_unique($$schema{"type"}) 0 360 360
59 }
60 else {
61 8255 ▶ return if not assert_keyword_type($state, $schema, 'string');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "string") 4 8251 8255
62 return E($state, 'unrecognized type "%s"', $schema->{type}//'<null>')
63 8251 ▶ if not any { ($schema->{type}//'') eq $_ } qw(null boolean object array string number integer);
Branch: 1 branch
BranchTrueFalseTotal
unless CORE::any {($$schema{"type"} // "") eq $_;} "null", "boolean", "object", "array", "string", "number", "integer" 4 8247 8251
Condition50%2/4
$$schema{"type"} // ""
l!l
388880
$$schema{"type"} // "<null>"
l!l
40
MC/DC0%0/1
$$schema{"type"} // ""
$$schema{"type"}
MC/DC0%0/1
$$schema{"type"} // "<null>"
$$schema{"type"}
Truth table50%1/2
A
A= $$schema{"type"}
Aresult
11
00
Truth table50%1/2
A
A= $$schema{"type"}
Aresult
11
00
64 }
65 8607 return 1;
66 }
67  
68 9017 ▶sub _eval_keyword_type ($class, $data, $schema, $state) {
Subroutine _eval_keyword_type: called CC=16 SCAR=27.7
69 9017 ▶ my $type = get_type($data, $state->{specification_version} eq 'draft4' ? { legacy_ints => 1 } : ());
Branch: 1 branch
BranchTrueFalseTotal
$$state{'specification_version'} eq 'draft4' ? : 1238 7779 9017
70 9017 ▶ my @want = ref $schema->{type} eq 'ARRAY' ? $schema->{type}->@* : $schema->{type};
Branch: 1 branch
BranchTrueFalseTotal
ref $$schema{'type'} eq 'ARRAY' ? : 1047 7970 9017
71  
72 9017 ▶ return 1 if any {
Branch: 1 branch
BranchTrueFalseTotal
if CORE::any {$type eq $_ or $_ eq "number" and $type eq "integer" or $type eq "string" and $$state{"stringy_numbers"} and &looks_like_number($data) and $_ eq "number" || $_ eq "integer" && $data == int $data or $_ eq "boolean" and $$state{"scalarref_booleans"} and $type eq "reference to SCALAR";} @want 6826 2191 9017
73 $type eq $_ or ($_ eq 'number' and $type eq 'integer')
74 or ($type eq 'string' and $state->{stringy_numbers} and looks_like_number($data)
75 and ($_ eq 'number' or ($_ eq 'integer' and $data == int($data))))
76 9267 ▶ or ($_ eq 'boolean' and $state->{scalarref_booleans} and $type eq 'reference to SCALAR')
Condition93%31/33
$type eq $_ || $_ eq 'number' && $type eq 'integer' || $type eq 'string' && $$state{'stringy_numbers'} && &looks_like_number($data) && ($_ eq 'number' || $_ eq 'integer' && $data == int $data) || $_ eq 'boolean' && $$state{'scalarref_booleans'} && $type eq 'reference to SCALAR'
l!l&&r!l&&!r
682242441
$type eq $_ or $_ eq "number" and $type eq "integer" or $type eq "string" and $$state{"stringy_numbers"} and &looks_like_number($data) and $_ eq "number" || $_ eq "integer" && $data == int $data
l!l&&r!l&&!r
682022445
$type eq $_ or $_ eq "number" and $type eq "integer"
l!l&&r!l&&!r
63944262447
$_ eq "number" and $type eq "integer"
!ll&&!rl&&r
2147300426
$type eq "string" and $$state{"stringy_numbers"} and &looks_like_number($data) and $_ eq "number" || $_ eq "integer" && $data == int $data
!ll&&!rl&&r
244142
$type eq "string" and $$state{"stringy_numbers"} and &looks_like_number($data)
!ll&&!rl&&r
243566
$type eq "string" and $$state{"stringy_numbers"}
!ll&&!rl&&r
151492112
$_ eq "number" or $_ eq "integer" and $data == int $data
l!l&&r!l&&!r
204
$_ eq "integer" and $data == int $data
!ll&&!rl&&r
220
$_ eq "boolean" and $$state{"scalarref_booleans"} and $type eq "reference to SCALAR"
!ll&&!rl&&r
2427144
$_ eq "boolean" and $$state{"scalarref_booleans"}
!ll&&!rl&&r
223319418
MC/DC83%10/12
$type eq $_ || $_ eq 'number' && $type eq 'integer' || $type eq 'string' && $$state{'stringy_numbers'} && &looks_like_number($data) && ($_ eq 'number' || $_ eq 'integer' && $data == int $data) || $_ eq 'boolean' && $$state{'scalarref_booleans'} && $type eq 'reference to SCALAR'
$type eq $_ $_ eq "number" $type eq "integer" $type eq "string" $$state{"stringy_numbers"} &looks_like_number($data) $_ eq "number" $_ eq "integer" $data == int $data $_ eq "boolean" $$state{"scalarref_booleans"} $type eq "reference to SCALAR"
Truth table34%16/46
A or B and C or D and E and F and G or H and I || J and K and L
A= $type eq $_B= $_ eq "number"C= $type eq "integer"D= $type eq "string"E= $$state{"stringy_numbers"}F= &looks_like_number($data)G= $_ eq "number"H= $_ eq "integer"I= $data == int $dataJ= $_ eq "boolean"K= $$state{"scalarref_booleans"}L= $type eq "reference to SCALAR"
ABCDEFGHIJKLresult
1XXXXXXXXXXX1
011XXXXXXXXX1
00X1111XXXXX1
00X111011XXX1
0101111XXXXX1
010111011XXX1
00X0XXXXX1111
00X10XXXX1111
00X110XXX1111
00X11100X1111
00X1110101111
0100XXXXX1111
01010XXXX1111
010110XXX1111
01011100X1111
0101110101111
00X0XXXXX0XX0
00X0XXXXX10X0
00X0XXXXX1100
00X10XXXX0XX0
00X10XXXX10X0
00X10XXXX1100
00X110XXX0XX0
00X110XXX10X0
00X110XXX1100
00X11100X0XX0
00X11100X10X0
00X11100X1100
00X1110100XX0
00X11101010X0
00X1110101100
0100XXXXX0XX0
0100XXXXX10X0
0100XXXXX1100
01010XXXX0XX0
01010XXXX10X0
01010XXXX1100
010110XXX0XX0
010110XXX10X0
010110XXX1100
01011100X0XX0
01011100X10X0
01011100X1100
0101110100XX0
01011101010X0
0101110101100
77 } @want;
78  
79 2191 ▶ return E($state, 'got %s, not %s%s', $type, (@want > 1 ? 'one of ' : ''), join(', ', @want));
Branch: 1 branch
BranchTrueFalseTotal
@want > 1 ? : 151 2040 2191
80 }
81  
82 902 ▶sub _traverse_keyword_enum ($class, $schema, $state) {
Subroutine _traverse_keyword_enum: called CC=1 SCAR=0.0
83 902 return assert_keyword_type($state, $schema, 'array');
84 }
85  
86 810 ▶sub _eval_keyword_enum ($class, $data, $schema, $state) {
Subroutine _eval_keyword_enum: called CC=3 SCAR=11.0
87 810 my @s; my $idx = 0;
88 810 my %s = $state->%{qw(scalarref_booleans stringy_numbers)};
89 810 ▶ return 1 if any { is_equal($data, $_, $s[$idx++] = {%s}) } $schema->{enum}->@*;
Branch: 1 branch
BranchTrueFalseTotal
if CORE::any {is_equal($data, $_, $s[$idx++] = {%s});} @{$$schema{"enum"}} 437 373 810
90 return E($state, 'value does not match ('
91 373 ▶ .(join('; ', map "from enum $_".(length $s[$_]->{path} ? " at '$s[$_]->{path}'" : '').": $s[$_]->{error}", 0..$#s).')'));
Branch: 1 branch
BranchTrueFalseTotal
length $s[$_]{'path'} ? : 71 629 700
92 }
93  
94 1481 ▶sub _traverse_keyword_const ($class, $schema, $state) { 1 }
Subroutine _traverse_keyword_const: called CC=1 SCAR=0.0
95  
96 1383 ▶sub _eval_keyword_const ($class, $data, $schema, $state) {
Subroutine _eval_keyword_const: called CC=3 SCAR=11.0
97 1383 my %s = $state->%{qw(scalarref_booleans stringy_numbers)};
98 1383 ▶ return 1 if is_equal($data, $schema->{const}, \%s);
Branch: 1 branch
BranchTrueFalseTotal
if is_equal($data, $$schema{"const"}, \%s) 732 651 1383
99 651 ▶ return E($state, 'value does not match ('.($s{path} ? "at '$s{path}': " : '').$s{error}.')');
Branch: 1 branch
BranchTrueFalseTotal
$s{'path'} ? : 73 578 651
100 }
101  
102 1169 ▶sub _traverse_keyword_multipleOf ($class, $schema, $state) {
Subroutine _traverse_keyword_multipleOf: called CC=3 SCAR=11.1
103 1169 ▶ return if not assert_keyword_type($state, $schema, 'number');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "number") 2 1167 1169
104 1167 ▶ return E($state, 'multipleOf value is not a positive number') if $schema->{multipleOf} <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $$schema{"multipleOf"} <= 0 0 1167 1167
105 1167 return 1;
106 }
107  
108 1176 ▶sub _eval_keyword_multipleOf ($class, $data, $schema, $state) {
Subroutine _eval_keyword_multipleOf: called CC=11 SCAR=24.0
109 return 1 if not is_type('number', $data)
110 and not ($state->{stringy_numbers} and is_type('string', $data) and looks_like_number($data)
111 1176 ▶ and do { $data = 0+$data; 1 });
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data) and do { $data = 0 + $data; 1 } 232 944 1176
Condition75%9/12
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data) and do { $data = 0 + $data; 1 }
l!l&&r!l&&!r
9422232
$$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data) and do { $data = 0 + $data; 1 }
!ll&&!rl&&r
23202
$$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
!ll&&!rl&&r
23202
$$state{"stringy_numbers"} and is_type("string", $data)
!ll&&!rl&&r
23202
MC/DC40%2/5
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data) and do { $data = 0 + $data; 1 }
is_type("number", $data) $$state{"stringy_numbers"} is_type("string", $data) &looks_like_number($data) do { $data = 0 + $data; 1 }
Truth table50%3/6
A or B and C and D and E
A= is_type("number", $data)B= $$state{"stringy_numbers"}C= is_type("string", $data)D= &looks_like_number($data)E= do { $data = 0 + $data; 1 }
ABCDEresult
1XXXX1
011111
00XXX0
010XX0
0110X0
011100
112  
113 944 my $remainder;
114  
115 944 ▶ if (get_type($data) eq 'integer' and get_type($schema->{multipleOf}) eq 'integer') {
Branch: 1 branch
BranchTrueFalseTotal
if (get_type($data) eq 'integer' and get_type($$schema{'multipleOf'}) eq 'integer') { } 787 157 944
Condition100%3/3
get_type($data) eq "integer" and get_type($$schema{"multipleOf"}) eq "integer"
!ll&&!rl&&r
8473787
MC/DC100%2/2
get_type($data) eq "integer" and get_type($$schema{"multipleOf"}) eq "integer"
get_type($data) eq "integer" get_type($$schema{"multipleOf"}) eq "integer"
Truth table100%3/3
A and B
A= get_type($data) eq "integer"B= get_type($$schema{"multipleOf"}) eq "integer"
ABresult
0X0
100
111
116 787 $remainder = $data % $schema->{multipleOf};
117 }
118 else {
119 # if either value is a float, use the bignum library for the calculation for an accurate remainder
120 157 ▶ my $dividend = is_bignum($data) ? $data->copy : Math::BigFloat->new($data);
Branch: 1 branch
BranchTrueFalseTotal
is_bignum($data) ? : 101 56 157
121 157 ▶ my $divisor = is_bignum($schema->{multipleOf}) ? $schema->{multipleOf} : Math::BigFloat->new($schema->{multipleOf});
Branch: 1 branch
BranchTrueFalseTotal
is_bignum($$schema{'multipleOf'}) ? : 131 26 157
122 157 $remainder = $dividend->bmod($divisor);
123 }
124  
125 944 ▶ return 1 if $remainder == 0;
Branch: 1 branch
BranchTrueFalseTotal
if $remainder == 0 507 437 944
126 437 return E($state, 'value is not a multiple of %s', sprintf_num($schema->{multipleOf}));
127 }
128  
129 38 *_traverse_keyword_maximum = \&_assert_number;
130  
131 825 ▶sub _eval_keyword_maximum ($class, $data, $schema, $state) {
Subroutine _eval_keyword_maximum: called CC=9 SCAR=22.0
132 return 1 if not is_type('number', $data)
133 825 ▶ and not ($state->{stringy_numbers} and is_type('string', $data) and looks_like_number($data));
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data) 243 582 825
Condition77%7/9
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
l!l&&r!l&&!r
5811243
$$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
!ll&&!rl&&r
24301
$$state{"stringy_numbers"} and is_type("string", $data)
!ll&&!rl&&r
24301
MC/DC50%2/4
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
is_type("number", $data) $$state{"stringy_numbers"} is_type("string", $data) &looks_like_number($data)
Truth table60%3/5
A or B and C and D
A= is_type("number", $data)B= $$state{"stringy_numbers"}C= is_type("string", $data)D= &looks_like_number($data)
ABCDresult
1XXX1
01111
00XX0
010X0
01100
134  
135 582 ▶ return 1 if 0+$data < $schema->{maximum};
Branch: 1 branch
BranchTrueFalseTotal
if 0 + $data < $$schema{"maximum"} 167 415 582
136 415 ▶ if ($state->{specification_version} eq 'draft4' and $schema->{exclusiveMaximum}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$state{'specification_version'} eq 'draft4' and $$schema{'exclusiveMaximum'}) { } 6 409 415
Condition100%3/3
$$state{"specification_version"} eq "draft4" and $$schema{"exclusiveMaximum"}
!ll&&!rl&&r
377326
MC/DC100%2/2
$$state{"specification_version"} eq "draft4" and $$schema{"exclusiveMaximum"}
$$state{"specification_version"} eq "draft4" $$schema{"exclusiveMaximum"}
Truth table100%3/3
A and B
A= $$state{"specification_version"} eq "draft4"B= $$schema{"exclusiveMaximum"}
ABresult
0X0
100
111
137 6 return E($state, 'value is greater than or equal to %s', sprintf_num($schema->{maximum}));
138 }
139 else {
140 409 ▶ return 1 if 0+$data == $schema->{maximum};
Branch: 1 branch
BranchTrueFalseTotal
if 0 + $data == $$schema{"maximum"} 163 246 409
141 246 return E($state, 'value is greater than %s', sprintf_num($schema->{maximum}));
142 }
143 }
144  
145 580 ▶sub _traverse_keyword_exclusiveMaximum ($class, $schema, $state) {
Subroutine _traverse_keyword_exclusiveMaximum: called CC=4 SCAR=14.2
146 580 ▶ return assert_keyword_type($state, $schema, 'number') if $state->{specification_version} ne 'draft4';
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} ne "draft4" 562 18 580
147  
148 18 ▶ return if not assert_keyword_type($state, $schema, 'boolean');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "boolean") 0 18 18
149 return E($state, 'use of exclusiveMaximum requires the presence of maximum')
150 18 ▶ if not exists $schema->{maximum};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $$schema{"maximum"} 0 18 18
151 18 return 1;
152 }
153  
154 563 ▶sub _eval_keyword_exclusiveMaximum ($class, $data, $schema, $state) {
Subroutine _eval_keyword_exclusiveMaximum: called CC=7 SCAR=19.5
155 # we do the work in "maximum" for draft4 so we don't generate multiple errors
156 563 ▶ return 1 if $state->{specification_version} eq 'draft4';
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} eq "draft4" 15 548 563
157  
158 return 1 if not is_type('number', $data)
159 548 ▶ and not ($state->{stringy_numbers} and is_type('string', $data) and looks_like_number($data));
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data) 229 319 548
Condition77%7/9
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
l!l&&r!l&&!r
3181229
$$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
!ll&&!rl&&r
22901
$$state{"stringy_numbers"} and is_type("string", $data)
!ll&&!rl&&r
22901
MC/DC50%2/4
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
is_type("number", $data) $$state{"stringy_numbers"} is_type("string", $data) &looks_like_number($data)
Truth table60%3/5
A or B and C and D
A= is_type("number", $data)B= $$state{"stringy_numbers"}C= is_type("string", $data)D= &looks_like_number($data)
ABCDresult
1XXX1
01111
00XX0
010X0
01100
160  
161 319 ▶ return 1 if 0+$data < $schema->{exclusiveMaximum};
Branch: 1 branch
BranchTrueFalseTotal
if 0 + $data < $$schema{"exclusiveMaximum"} 148 171 319
162 171 return E($state, 'value is greater than or equal to %s', sprintf_num($schema->{exclusiveMaximum}));
163 }
164  
165 38 *_traverse_keyword_minimum = \&_assert_number;
166  
167 946 ▶sub _eval_keyword_minimum ($class, $data, $schema, $state) {
Subroutine _eval_keyword_minimum: called CC=9 SCAR=22.0
168 return 1 if not is_type('number', $data)
169 946 ▶ and not ($state->{stringy_numbers} and is_type('string', $data) and looks_like_number($data));
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data) 259 687 946
Condition77%7/9
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
l!l&&r!l&&!r
6861259
$$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
!ll&&!rl&&r
25901
$$state{"stringy_numbers"} and is_type("string", $data)
!ll&&!rl&&r
25901
MC/DC50%2/4
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
is_type("number", $data) $$state{"stringy_numbers"} is_type("string", $data) &looks_like_number($data)
Truth table60%3/5
A or B and C and D
A= is_type("number", $data)B= $$state{"stringy_numbers"}C= is_type("string", $data)D= &looks_like_number($data)
ABCDresult
1XXX1
01111
00XX0
010X0
01100
170  
171 687 ▶ return 1 if 0+$data > $schema->{minimum};
Branch: 1 branch
BranchTrueFalseTotal
if 0 + $data > $$schema{"minimum"} 176 511 687
172 511 ▶ if ($state->{specification_version} eq 'draft4' and $schema->{exclusiveMinimum}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$state{'specification_version'} eq 'draft4' and $$schema{'exclusiveMinimum'}) { } 4 507 511
Condition100%3/3
$$state{"specification_version"} eq "draft4" and $$schema{"exclusiveMinimum"}
!ll&&!rl&&r
474334
MC/DC100%2/2
$$state{"specification_version"} eq "draft4" and $$schema{"exclusiveMinimum"}
$$state{"specification_version"} eq "draft4" $$schema{"exclusiveMinimum"}
Truth table100%3/3
A and B
A= $$state{"specification_version"} eq "draft4"B= $$schema{"exclusiveMinimum"}
ABresult
0X0
100
111
173 4 return E($state, 'value is less than or equal to %s', sprintf_num($schema->{minimum}));
174 }
175 else {
176 507 ▶ return 1 if 0+$data == $schema->{minimum};
Branch: 1 branch
BranchTrueFalseTotal
if 0 + $data == $$schema{"minimum"} 184 323 507
177 323 return E($state, 'value is less than %s', sprintf_num($schema->{minimum}));
178 }
179 }
180  
181 515 ▶sub _traverse_keyword_exclusiveMinimum ($class, $schema, $state) {
Subroutine _traverse_keyword_exclusiveMinimum: called CC=4 SCAR=14.2
182 515 ▶ return assert_keyword_type($state, $schema, 'number') if $state->{specification_version} ne 'draft4';
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} ne "draft4" 499 16 515
183  
184 16 ▶ return if not assert_keyword_type($state, $schema, 'boolean');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "boolean") 0 16 16
185 return E($state, 'use of exclusiveMinimum requires the presence of minimum')
186 16 ▶ if not exists $schema->{minimum};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $$schema{"minimum"} 0 16 16
187 16 return 1;
188 }
189  
190 496 ▶sub _eval_keyword_exclusiveMinimum ($class, $data, $schema, $state) {
Subroutine _eval_keyword_exclusiveMinimum: called CC=7 SCAR=19.5
191 # we do the work in "minimum" for draft4 so we don't generate multiple errors
192 496 ▶ return 1 if $state->{specification_version} eq 'draft4';
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} eq "draft4" 11 485 496
193  
194 return 1 if not is_type('number', $data)
195 485 ▶ and not ($state->{stringy_numbers} and is_type('string', $data) and looks_like_number($data));
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data) 229 256 485
Condition77%7/9
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
l!l&&r!l&&!r
2551229
$$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
!ll&&!rl&&r
22901
$$state{"stringy_numbers"} and is_type("string", $data)
!ll&&!rl&&r
22901
MC/DC50%2/4
is_type("number", $data) or $$state{"stringy_numbers"} and is_type("string", $data) and &looks_like_number($data)
is_type("number", $data) $$state{"stringy_numbers"} is_type("string", $data) &looks_like_number($data)
Truth table60%3/5
A or B and C and D
A= is_type("number", $data)B= $$state{"stringy_numbers"}C= is_type("string", $data)D= &looks_like_number($data)
ABCDresult
1XXX1
01111
00XX0
010X0
01100
196  
197 256 ▶ return 1 if 0+$data > $schema->{exclusiveMinimum};
Branch: 1 branch
BranchTrueFalseTotal
if 0 + $data > $$schema{"exclusiveMinimum"} 118 138 256
198 138 return E($state, 'value is less than or equal to %s', sprintf_num($schema->{exclusiveMinimum}));
199 }
200  
201 38 *_traverse_keyword_maxLength = \&_assert_non_negative_integer;
202  
203 666 ▶sub _eval_keyword_maxLength ($class, $data, $schema, $state) {
Subroutine _eval_keyword_maxLength: called CC=3 SCAR=11.0
204 666 ▶ return 1 if not is_type('string', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("string", $data) 249 417 666
205 417 ▶ return 1 if length($data) <= $schema->{maxLength};
Branch: 1 branch
BranchTrueFalseTotal
if length $data <= $$schema{"maxLength"} 224 193 417
206 193 return E($state, 'length is greater than %d', $schema->{maxLength});
207 }
208  
209 38 *_traverse_keyword_minLength = \&_assert_non_negative_integer;
210  
211 621 ▶sub _eval_keyword_minLength ($class, $data, $schema, $state) {
Subroutine _eval_keyword_minLength: called CC=3 SCAR=11.0
212 621 ▶ return 1 if not is_type('string', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("string", $data) 253 368 621
213 368 ▶ return 1 if length($data) >= $schema->{minLength};
Branch: 1 branch
BranchTrueFalseTotal
if length $data >= $$schema{"minLength"} 199 169 368
214 169 return E($state, 'length is less than %d', $schema->{minLength});
215 }
216  
217 1301 ▶sub _traverse_keyword_pattern ($class, $schema, $state) {
Subroutine _traverse_keyword_pattern: called CC=3 SCAR=11.1
218 return if not assert_keyword_type($state, $schema, 'string')
219 1301 ▶ or not assert_pattern($state, $schema->{pattern});
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "string") and assert_pattern($state, $$schema{"pattern"}) 2 1299 1301
Condition66%2/3
assert_keyword_type($state, $schema, "string") and assert_pattern($state, $$schema{"pattern"})
!ll&&!rl&&r
021299
MC/DC50%1/2
assert_keyword_type($state, $schema, "string") and assert_pattern($state, $$schema{"pattern"})
assert_keyword_type($state, $schema, "string") assert_pattern($state, $$schema{"pattern"})
Truth table66%2/3
A and B
A= assert_keyword_type($state, $schema, "string")B= assert_pattern($state, $$schema{"pattern"})
ABresult
0X0
100
111
220 1299 return 1;
221 }
222  
223 1290 ▶sub _eval_keyword_pattern ($class, $data, $schema, $state) {
Subroutine _eval_keyword_pattern: called CC=3 SCAR=11.0
224 1290 ▶ return 1 if not is_type('string', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("string", $data) 289 1001 1290
225  
226 # ECMA-262 restricts \d, \s, \w to ascii ranges
227 1001 ▶ return 1 if $data =~ m/(?:$schema->{pattern})/a;
Branch: 1 branch
BranchTrueFalseTotal
if $data =~ /(?:$$schema{"pattern"})/a 513 487 1000
228 487 return E($state, 'pattern does not match');
229 }
230  
231 38 *_traverse_keyword_maxItems = \&_assert_non_negative_integer;
232  
233 488 ▶sub _eval_keyword_maxItems ($class, $data, $schema, $state) {
Subroutine _eval_keyword_maxItems: called CC=4 SCAR=13.9
234 488 ▶ return 1 if not is_type('array', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("array", $data) 196 292 488
235 292 ▶ return 1 if @$data <= $schema->{maxItems};
Branch: 1 branch
BranchTrueFalseTotal
if @$data <= $$schema{"maxItems"} 156 136 292
236 136 ▶ return E($state, 'array has more than %d item%s', $schema->{maxItems}, $schema->{maxItems} > 1 ? 's' : '');
Branch: 1 branch
BranchTrueFalseTotal
$$schema{'maxItems'} > 1 ? : 32 104 136
237 }
238  
239 38 *_traverse_keyword_minItems = \&_assert_non_negative_integer;
240  
241 531 ▶sub _eval_keyword_minItems ($class, $data, $schema, $state) {
Subroutine _eval_keyword_minItems: called CC=4 SCAR=13.9
242 531 ▶ return 1 if not is_type('array', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("array", $data) 222 309 531
243 309 ▶ return 1 if @$data >= $schema->{minItems};
Branch: 1 branch
BranchTrueFalseTotal
if @$data >= $$schema{"minItems"} 167 142 309
244 142 ▶ return E($state, 'array has fewer than %d item%s', $schema->{minItems}, $schema->{minItems} > 1 ? 's' : '');
Branch: 1 branch
BranchTrueFalseTotal
$$schema{'minItems'} > 1 ? : 124 18 142
245 }
246  
247 1109 ▶sub _traverse_keyword_uniqueItems ($class, $schema, $state) {
Subroutine _traverse_keyword_uniqueItems: called CC=1 SCAR=0.0
248 1109 return assert_keyword_type($state, $schema, 'boolean');
249 }
250  
251 1080 ▶sub _eval_keyword_uniqueItems ($class, $data, $schema, $state) {
Subroutine _eval_keyword_uniqueItems: called CC=4 SCAR=13.9
252 1080 ▶ return 1 if not is_type('array', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("array", $data) 212 868 1080
253 868 ▶ return 1 if not $schema->{uniqueItems};
Branch: 1 branch
BranchTrueFalseTotal
unless $$schema{"uniqueItems"} 260 608 868
254 608 ▶ return 1 if is_elements_unique($data, my $s = +{ $state->%{qw(scalarref_booleans stringy_numbers)}, equal_indices => [] });
Branch: 1 branch
BranchTrueFalseTotal
if is_elements_unique($data, my $s = {%$state{"scalarref_booleans", "stringy_numbers"}, "equal_indices", []}) 328 280 608
255 280 return E($state, 'items at indices %d and %d are not unique', $s->{equal_indices}->@*);
256 }
257  
258 # The evaluation implementations of maxContains and minContains are in the Applicator vocabulary,
259 # as 'contains' needs to run first
260 38 *_traverse_keyword_maxContains = \&_assert_non_negative_integer;
261  
262 38 *_traverse_keyword_minContains = \&_assert_non_negative_integer;
263  
264 38 *_traverse_keyword_maxProperties = \&_assert_non_negative_integer;
265  
266 399 ▶sub _eval_keyword_maxProperties ($class, $data, $schema, $state) {
Subroutine _eval_keyword_maxProperties: called CC=4 SCAR=13.9
267 399 ▶ return 1 if not is_type('object', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("object", $data) 165 234 399
268 234 ▶ return 1 if keys %$data <= $schema->{maxProperties};
Branch: 1 branch
BranchTrueFalseTotal
if keys %$data <= $$schema{"maxProperties"} 122 112 234
269 return E($state, 'object has more than %d propert%s', $schema->{maxProperties},
270 112 ▶ $schema->{maxProperties} > 1 ? 'ies' : 'y');
Branch: 1 branch
BranchTrueFalseTotal
$$schema{'maxProperties'} > 1 ? : 18 94 112
271 }
272  
273 38 *_traverse_keyword_minProperties = \&_assert_non_negative_integer;
274  
275 423 ▶sub _eval_keyword_minProperties ($class, $data, $schema, $state) {
Subroutine _eval_keyword_minProperties: called CC=4 SCAR=13.9
276 423 ▶ return 1 if not is_type('object', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("object", $data) 185 238 423
277 238 ▶ return 1 if keys %$data >= $schema->{minProperties};
Branch: 1 branch
BranchTrueFalseTotal
if keys %$data >= $$schema{"minProperties"} 122 116 238
278 return E($state, 'object has fewer than %d propert%s', $schema->{minProperties},
279 116 ▶ $schema->{minProperties} > 1 ? 'ies' : 'y');
Branch: 1 branch
BranchTrueFalseTotal
$$schema{'minProperties'} > 1 ? : 14 102 116
280 }
281  
282 2127 ▶sub _traverse_keyword_required ($class, $schema, $state) {
Subroutine _traverse_keyword_required: called CC=7 SCAR=22.9
283 2127 ▶ return if not assert_keyword_type($state, $schema, 'array');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "array") 0 2127 2127
284 2127 ▶ return E($state, '"required" array is empty') if $state->{specification_version} eq 'draft4' and not $schema->{required}->@*;
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} eq "draft4" and not @{$$schema{"required"}} 0 2127 2127
Condition66%2/3
$$state{"specification_version"} eq "draft4" and not @{$$schema{"required"}}
!ll&&!rl&&r
19391880
MC/DC0%0/2
$$state{"specification_version"} eq "draft4" and not @{$$schema{"required"}}
$$state{"specification_version"} eq "draft4" not @{$$schema{"required"}}
Truth table66%2/3
A and not(B)
A= $$state{"specification_version"} eq "draft4"B= not @{$$schema{"required"}}
ABresult
0X0
100
111
285  
286 2127 ▶ if (my @non_string = grep !is_type('string', $schema->{required}->[$_]), 0 .. $schema->{required}->$#*) {
Branch: 1 branch
BranchTrueFalseTotal
if (my(@non_string) = grep((!is_type("string", $$schema{"required"}[$_])), 0 .. $$schema{"required"}->$#*)) 0 2127 2127
287 ()= E({ %$state, _keyword_path_suffix => $_ }, '"required" element is not a string')
288 0 foreach @non_string;
289 0 return;
290 }
291  
292 2127 ▶ return E($state, '"required" values are not unique') if not is_elements_unique($schema->{required});
Branch: 1 branch
BranchTrueFalseTotal
unless is_elements_unique($$schema{"required"}) 0 2127 2127
293 2127 return 1;
294 }
295  
296 2293 ▶sub _eval_keyword_required ($class, $data, $schema, $state) {
Subroutine _eval_keyword_required: called CC=4 SCAR=13.9
297 2293 ▶ return 1 if not is_type('object', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("object", $data) 205 2088 2293
298  
299 2088 my @missing = grep !exists $data->{$_}, $schema->{required}->@*;
300 2088 ▶ return 1 if not @missing;
Branch: 1 branch
BranchTrueFalseTotal
unless @missing 1265 823 2088
301 823 ▶ return E($state, 'object is missing propert%s: %s', @missing > 1 ? 'ies' : 'y', join(', ', @missing));
Branch: 1 branch
BranchTrueFalseTotal
@missing > 1 ? : 60 763 823
302 }
303  
304 319 ▶sub _traverse_keyword_dependentRequired ($class, $schema, $state) {
Subroutine _traverse_keyword_dependentRequired: called CC=7 SCAR=19.9
305 319 ▶ return if not assert_keyword_type($state, $schema, 'object');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "object") 0 319 319
306  
307 319 my $valid = 1;
308 319 foreach my $property (sort keys $schema->{dependentRequired}->%*) {
309 $valid = E({ %$state, _keyword_path_suffix => $property }, 'value is not an array'), next
310 335 ▶ if not is_type('array', $schema->{dependentRequired}{$property});
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("array", $$schema{"dependentRequired"}{$property}) 0 335 335
311  
312 335 foreach my $index (0..$schema->{dependentRequired}{$property}->$#*) {
313 $valid = E({ %$state, _keyword_path_suffix => [ $property, $index ] }, 'element is not a string')
314 349 ▶ if not is_type('string', $schema->{dependentRequired}{$property}[$index]);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("string", $$schema{"dependentRequired"}{$property}[$index]) 1 348 349
315 }
316  
317 $valid = E({ %$state, _keyword_path_suffix => $property }, 'elements are not unique')
318 335 ▶ if not is_elements_unique($schema->{dependentRequired}{$property});
Branch: 1 branch
BranchTrueFalseTotal
unless is_elements_unique($$schema{"dependentRequired"}{$property}) 0 335 335
319 }
320 319 return $valid;
321 }
322  
323 295 ▶sub _eval_keyword_dependentRequired ($class, $data, $schema, $state) {
Subroutine _eval_keyword_dependentRequired: called CC=7 SCAR=19.5
324 295 ▶ return 1 if not is_type('object', $data);
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("object", $data) 110 185 295
325  
326 185 my $valid = 1;
327 185 foreach my $property (sort keys $schema->{dependentRequired}->%*) {
328 201 ▶ next if not exists $data->{$property};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $$data{$property} 36 165 201
329  
330 165 ▶ if (my @missing = grep !exists($data->{$_}), $schema->{dependentRequired}{$property}->@*) {
Branch: 1 branch
BranchTrueFalseTotal
if (my(@missing) = grep((!exists($$data{$_})), @{$$schema{"dependentRequired"}{$property}})) 85 80 165
331 85 ▶ $valid = E({ %$state, _keyword_path_suffix => $property },
Branch: 1 branch
BranchTrueFalseTotal
@missing > 1 ? : 5 80 85
332 'object is missing propert%s: %s', @missing > 1 ? 'ies' : 'y', join(', ', @missing));
333 }
334 }
335  
336 185 ▶ return 1 if $valid;
Branch: 1 branch
BranchTrueFalseTotal
if $valid 100 85 185
337 85 return E($state, 'not all dependencies are satisfied');
338 }
339  
340 1827 ▶sub _assert_number ($class, $schema, $state) {
Subroutine _assert_number: called CC=1 SCAR=0.0
341 1827 return assert_keyword_type($state, $schema, 'number');
342 }
343  
344 3735 ▶sub _assert_non_negative_integer ($class, $schema, $state) {
Subroutine _assert_non_negative_integer: called CC=3 SCAR=11.7
345 3735 ▶ return if not assert_keyword_type($state, $schema, 'integer');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "integer") 0 3735 3735
346 return E($state, '%s value is not a non-negative integer', $state->{keyword})
347 3735 ▶ if $schema->{$state->{keyword}} < 0;
Branch: 1 branch
BranchTrueFalseTotal
if $$schema{$$state{"keyword"}} < 0 0 3735 3735
348 3735 return 1;
349 }
350  
351 38 1;
352  
353 __END__
« Modern/Vocabulary/Core.pm ↑ Summary Modern/ResultNode.pm »