Modern/Vocabulary/Core.pm

filter: Statementstmt 100% 171 / 171 Branchbran 89.8% 106 / 118 Conditioncond 88.4% 61 / 69 MC/DCmcdc 72.9% 27 / 37 Subroutinesub 100% 38 / 38 Podpod 0.0% 0 / 3 totaltotal 92.4% 403 / 436 CC 86 SCAR 20.7
CC
86
Cov
94%
_traverse_keyword_schema
15.0
_traverse_keyword_anchor
14.0
__resolve_dynamicRef
12.0
CRAP 7.9
« Modern/Vocabulary/Unevaluated.pm ↑ Summary Modern/Vocabulary/Validation.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::Core;
4 # vim: set ts=8 sts=2 sw=2 tw=100 et :
5 # ABSTRACT: Implementation of the JSON Schema Core 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 JSON::Schema::Modern::Utilities qw(is_type abort assert_keyword_type canonical_uri E assert_uri_reference assert_uri jsonp);
Subroutine BEGIN: called CC=1 SCAR=0.0
22 38 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
23  
24 38 with 'JSON::Schema::Modern::Vocabulary';
25  
26 22 ▶sub vocabulary ($class) {
Subroutine vocabulary: called CC=1 SCAR=0.0
Pod undocumented
27 22 'https://json-schema.org/draft/2019-09/vocab/core' => 'draft2019-09',
28 'https://json-schema.org/draft/2020-12/vocab/core' => 'draft2020-12';
29 }
30  
31 41 ▶sub evaluation_order ($class) { 0 }
Subroutine evaluation_order: called CC=1 SCAR=0.0
Pod undocumented
32  
33 201 ▶sub keywords ($class, $spec_version) {
Subroutine keywords: called CC=10 SCAR=23.0
Pod undocumented
34 return (
35 201 ▶ '$schema', # must be first to ensure we use the correct Core keywords and subsequent vocabularies
Branch: 9 branches
BranchTrueFalseTotal
$spec_version eq 'draft4' ? : 20 181 201
!($spec_version =~ /^draft[467]\z/u) ? : 137 64 201
$spec_version eq 'draft2019-09' ? : 45 156 201
!($spec_version =~ /^draft(?:[467]|2019-09)\z/u) ? : 92 109 201
$spec_version eq 'draft2019-09' ? : 45 156 201
!($spec_version =~ /^draft(?:[467]|2019-09)\z/u) ? : 92 109 201
!($spec_version =~ /^draft[467]\z/u) ? : 137 64 201
$spec_version =~ /^draft[467]\z/u ? : 64 137 201
!($spec_version =~ /^draft[46]\z/u) ? : 168 33 201
36 $spec_version eq 'draft4' ? 'id' : '$id',
37 $spec_version !~ /^draft[467]\z/ ? '$anchor' : (),
38 $spec_version eq 'draft2019-09' ? '$recursiveAnchor' : (),
39 $spec_version !~ /^draft(?:[467]|2019-09)\z/ ? '$dynamicAnchor' : (),
40 '$ref',
41 $spec_version eq 'draft2019-09' ? '$recursiveRef' : (),
42 $spec_version !~ /^draft(?:[467]|2019-09)\z/ ? '$dynamicRef' : (),
43 $spec_version !~ /^draft[467]\z/ ? '$vocabulary' : (),
44 $spec_version =~ /^draft[467]\z/ ? 'definitions' : '$defs',
45 $spec_version !~ /^draft[46]\z/ ? '$comment' : (),
46 );
47 }
48  
49 # adds the following keys to $state during traversal:
50 # - identifiers: an arrayref of tuples:
51 # $uri => { path => $path_to_identifier, canonical_uri => Mojo::URL (absolute when possible) }
52 # this is used by the Document constructor to build its resource_index.
53  
54 2146 ▶sub _traverse_keyword_id ($class, $schema, $state) {
Subroutine _traverse_keyword_id: called CC=9 SCAR=22.0
55 2146 ▶ return if not assert_keyword_type($state, $schema, 'string')
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "string") and assert_uri_reference($state, $schema) 2 2144 2146
Condition66%2/3
assert_keyword_type($state, $schema, "string") and assert_uri_reference($state, $schema)
!ll&&!rl&&r
022144
MC/DC50%1/2
assert_keyword_type($state, $schema, "string") and assert_uri_reference($state, $schema)
assert_keyword_type($state, $schema, "string") assert_uri_reference($state, $schema)
Truth table66%2/3
A and B
A= assert_keyword_type($state, $schema, "string")B= assert_uri_reference($state, $schema)
ABresult
0X0
100
111
56 or not assert_uri_reference($state, $schema);
57  
58 2144 my $uri = Mojo::URL->new($schema->{$state->{keyword}});
59  
60 2144 ▶ if (length $uri->fragment) {
Branch: 1 branch
BranchTrueFalseTotal
if (length $uri->fragment) 98 2046 2144
61 return E($state, '%s value "%s" cannot have a non-empty fragment', $state->{keyword}, $schema->{$state->{keyword}})
62 98 ▶ if $state->{specification_version} !~ /^draft[467]\z/;
Branch: 1 branch
BranchTrueFalseTotal
unless $$state{"specification_version"} =~ /^draft[467]\z/u 4 94 98
63  
64 94 ▶ if (length(my $base = $uri->clone->fragment(undef))) {
Branch: 1 branch
BranchTrueFalseTotal
if (length(my $base = $uri->clone->fragment(undef))) 15 79 94
65 return E($state, '$id cannot change the base uri at the same time as declaring an anchor')
66 15 ▶ if $state->{specification_version} =~ /^draft[67]\z/;
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} =~ /^draft[67]\z/u 2 13 15
67  
68 # only permitted in draft4: add an id and an anchor via the single 'id' keyword
69 13 ▶ return if not $class->__create_identifier($base, $state);
Branch: 1 branch
BranchTrueFalseTotal
unless $class->__create_identifier($base, $state) 0 13 13
70 }
71  
72 92 return $class->_traverse_keyword_anchor({ %$schema, id => '#'.$uri->fragment }, $state);
73 }
74  
75 2046 ▶ return if not $class->__create_identifier($uri, $state);
Branch: 1 branch
BranchTrueFalseTotal
unless $class->__create_identifier($uri, $state) 26 2020 2046
76 2020 return 1;
77 }
78  
79 2059 ▶sub __create_identifier ($class, $uri, $state) {
Subroutine __create_identifier: called CC=4 SCAR=13.9
80 2059 $uri->fragment(undef);
81 2059 ▶ return E($state, '%s cannot be empty', $state->{keyword}) if not length $uri;
Branch: 1 branch
BranchTrueFalseTotal
unless length $uri 24 2035 2059
82  
83 2035 ▶ $uri = $uri->to_abs($state->{initial_schema_uri}) if not $uri->is_abs;
Branch: 1 branch
BranchTrueFalseTotal
unless $uri->is_abs 732 1303 2035
84  
85 return E($state, 'duplicate canonical uri "%s" found (original at path "%s")',
86 $uri, $state->{identifiers}{$uri}{path})
87 2035 ▶ if exists $state->{identifiers}{$uri};
Branch: 1 branch
BranchTrueFalseTotal
if exists $$state{"identifiers"}{$uri} 2 2033 2035
88  
89 2033 $state->{initial_schema_uri} = $uri;
90 2033 $state->{traversed_keyword_path} = $state->{traversed_keyword_path}.$state->{keyword_path};
91 2033 $state->{keyword_path} = '';
92  
93 # Note that since '$schema' is considered ahead of '$id' in the keyword list, the dialect
94 # (specification_version and vocabularies) is known to be correct.
95  
96 $state->{identifiers}{$uri} = {
97 path => $state->{traversed_keyword_path},
98 canonical_uri => $uri,
99 2033 $state->%{qw(specification_version vocabularies)},
100 };
101  
102 2033 return 1;
103 }
104  
105 2716 ▶sub _eval_keyword_id ($class, $, $schema, $state) {
Subroutine _eval_keyword_id: called CC=6 SCAR=18.0
106 # we already indexed the anchor uri, so there is nothing more to do at evaluation time.
107 # we explicitly do NOT set $state->{initial_schema_uri} or change any other $state values.
108 return 1
109 2716 ▶ if $state->{specification_version} =~ /^draft[467]\z/ and $schema->{$state->{keyword}} =~ /^#/;
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} =~ /^draft[467]\z/u and $$schema{$$state{"keyword"}} =~ /^#/u 65 2651 2716
Condition100%3/3
$$state{"specification_version"} =~ /^draft[467]\z/u and $$schema{$$state{"keyword"}} =~ /^#/u
!ll&&!rl&&r
206858365
MC/DC100%2/2
$$state{"specification_version"} =~ /^draft[467]\z/u and $$schema{$$state{"keyword"}} =~ /^#/u
$$state{"specification_version"} =~ /^draft[467]\z/u $$schema{$$state{"keyword"}} =~ /^#/u
Truth table100%3/3
A and B
A= $$state{"specification_version"} =~ /^draft[467]\z/uB= $$schema{$$state{"keyword"}} =~ /^#/u
ABresult
0X0
100
111
110  
111 2651 my $schema_info = $state->{evaluator}->_fetch_from_uri($state->{initial_schema_uri}->clone->fragment($state->{keyword_path}));
112  
113 # this should never happen, if the pre-evaluation traversal was performed correctly
114 2651 ▶ abort($state, 'failed to resolve "%s" to canonical uri', $state->{keyword}) if not $schema_info;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema_info 0 2651 2651
115  
116 # $state->{document} is set by evaluate() and does not change unless following a reference
117 abort($state, 'EXCEPTION: mismatched document when processing %s "%s"',
118 $state->{keyword}, $schema->{$state->{keyword}})
119 2651 ▶ if $schema_info->{document} != $state->{document};
Branch: 1 branch
BranchTrueFalseTotal
if $$schema_info{"document"} != $$state{"document"} 0 2651 2651
120  
121 # these will all be set when we are at the document root, or if we are here via a $ref,
122 # but not if we are organically passing through this subschema.
123 2651 $state->{initial_schema_uri} = $schema_info->{canonical_uri};
124 2651 $state->{traversed_keyword_path} = $state->{traversed_keyword_path}.$state->{keyword_path};
125 2651 $state->{keyword_path} = '';
126 2651 $state->@{qw(specification_version vocabularies)} = $schema_info->@{qw(specification_version vocabularies)};
127  
128 push $state->{dynamic_scope}->@*, $state->{initial_schema_uri}
129 2651 ▶ if $state->{dynamic_scope}->[-1] ne $schema_info->{canonical_uri};
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"dynamic_scope"}[-1] ne $$schema_info{"canonical_uri"} 157 2494 2651
130  
131 2651 return 1;
132 }
133  
134 5895 ▶sub _traverse_keyword_schema ($class, $schema, $state) {
Subroutine _traverse_keyword_schema: called CC=15 SCAR=27.1
135 # Note that this sub is sometimes called with $state->{keyword} undefined, in order to change
136 # error locations
137  
138 # Note that because this keyword is parsed ahead of "id"/"$id", location information may not
139 # be correct if an error occurs when parsing this keyword.
140 5895 ▶ return E($state, '$schema value is not a string') if not is_type('string', $schema->{'$schema'});
Branch: 1 branch
BranchTrueFalseTotal
unless is_type("string", $$schema{"\$schema"}) 2 5893 5895
141 5893 ▶ return if not assert_uri($state, $schema, $schema->{'$schema'});
Branch: 1 branch
BranchTrueFalseTotal
unless assert_uri($state, $schema, $$schema{"\$schema"}) 3 5890 5893
142  
143 5890 my ($spec_version, $vocabularies);
144  
145 5890 ▶ if (my $metaschema_info = $state->{evaluator}->_get_metaschema_vocabulary_classes($schema->{'$schema'})) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $metaschema_info = $$state{'evaluator'}->_get_metaschema_vocabulary_classes($$schema{'$schema'})) { } 5833 57 5890
146 5833 ($spec_version, $vocabularies) = @$metaschema_info;
147 }
148 else {
149 57 my $schema_info = $state->{evaluator}->_fetch_from_uri($schema->{'$schema'});
150 57 ▶ return E($state, 'EXCEPTION: unable to find resource "%s"', $schema->{'$schema'}) if not $schema_info;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema_info 2 55 57
151 # this cannot happen unless there are other entity types in the index
152 return E($state, 'EXCEPTION: bad reference to $schema "%s": not a schema', $schema_info->{canonical_uri})
153 55 ▶ if $schema_info->{document}->get_entity_at_location($schema_info->{document_path}) ne 'schema';
Branch: 1 branch
BranchTrueFalseTotal
if $$schema_info{"document"}->get_entity_at_location($$schema_info{"document_path"}) ne "schema" 1 54 55
154  
155 54 ▶ if (ref $schema_info->{schema} ne 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $$schema_info{'schema'} ne 'HASH') { } 1 53 54
156 1 ()= E($state, 'metaschemas must be objects');
157 }
158 else {
159 ($spec_version, $vocabularies) = $state->{evaluator}->_fetch_vocabulary_data({ %$state,
160 keyword => '$vocabulary', initial_schema_uri => Mojo::URL->new($schema->{'$schema'}),
161 53 ▶ traversed_keyword_path => jsonp($state->{traversed_keyword_path}.$state->{keyword_path}, $state->{keyword}//()) },
Condition66%2/3
$$state{"keyword"} // ()
l!l&&r!l&&!r
4850
MC/DC0%0/2
$$state{"keyword"} // ()
$$state{"keyword"} ()
Truth table66%2/3
A // B
A= $$state{"keyword"}B= ()
ABresult
1X1
011
000
162 $schema_info);
163 }
164 }
165  
166 5887 ▶ return E($state, '"%s" is not a valid metaschema', $schema->{'$schema'})
Branch: 1 branch
BranchTrueFalseTotal
unless $vocabularies and @$vocabularies 20 5867 5887
Condition100%3/3
$vocabularies and @$vocabularies
!ll&&!rl&&r
1195867
MC/DC100%2/2
$vocabularies and @$vocabularies
$vocabularies @$vocabularies
Truth table100%3/3
A and B
A= $vocabulariesB= @$vocabularies
ABresult
0X0
100
111
167 if not $vocabularies or not @$vocabularies;
168  
169 # "A JSON Schema resource is a schema which is canonically identified by an absolute URI."
170 # "A resource's root schema is its top-level schema object."
171 # note: we need not be at the document root, but simply adjacent to an $id (or be the at the
172 # document root)
173 return E($state, '$schema can only appear at the schema resource root')
174 if not exists $schema->{$spec_version eq 'draft4' ? 'id' : '$id'}
175 5867 ▶ and length($state->{keyword_path});
Branch: 2 branches
BranchTrueFalseTotal
if not exists $$schema{$spec_version eq "draft4" ? "id" : "\$id"} and length $$state{"keyword_path"} 4 5863 5867
$spec_version eq 'draft4' ? : 11 5856 5867
Condition100%3/3
not exists $$schema{$spec_version eq "draft4" ? "id" : "\$id"} and length $$state{"keyword_path"}
!ll&&!rl&&r
63752264
MC/DC100%2/2
not exists $$schema{$spec_version eq "draft4" ? "id" : "\$id"} and length $$state{"keyword_path"}
not exists $$schema{$spec_version eq "draft4" ? "id" : "\$id"} length $$state{"keyword_path"}
Truth table100%3/3
not(A) and B
A= not exists $$schema{$spec_version eq "draft4" ? "id" : "\$id"}B= length $$state{"keyword_path"}
ABresult
0X0
100
111
176  
177 # This is a bit of a chicken-and-egg situation. If we start off at draft2020-12, then all
178 # keywords are valid, so we inspect and process the $schema keyword; this switches us to draft7
179 # but now only the $ref keyword is respected and everything else should be ignored, so the
180 # $schema keyword never happened, so now we're back to draft2020-12 again, and...?!
181 # The only winning move is not to play.
182 return E($state, '$schema and $ref cannot be used together in older drafts')
183 5863 ▶ if exists $schema->{'$ref'} and $spec_version =~ /^draft[467]\z/;
Branch: 1 branch
BranchTrueFalseTotal
if exists $$schema{"\$ref"} and $spec_version =~ /^draft[467]\z/u 1 5862 5863
Condition100%3/3
exists $$schema{"\$ref"} and $spec_version =~ /^draft[467]\z/u
!ll&&!rl&&r
54923701
MC/DC100%2/2
exists $$schema{"\$ref"} and $spec_version =~ /^draft[467]\z/u
exists $$schema{"\$ref"} $spec_version =~ /^draft[467]\z/u
Truth table100%3/3
A and B
A= exists $$schema{"\$ref"}B= $spec_version =~ /^draft[467]\z/u
ABresult
0X0
100
111
184  
185 5862 $state->{evaluator}->_set_metaschema_vocabulary_classes($schema->{'$schema'}, [ $spec_version, $vocabularies ]);
186 5862 $state->@{qw(specification_version vocabularies metaschema_uri)} = ($spec_version, $vocabularies, $schema->{'$schema'} =~ s/#\z//r);
187 5862 return 1;
188 }
189  
190 6585 ▶sub _eval_keyword_schema ($class, $, $schema, $state) {
Subroutine _eval_keyword_schema: called CC=1 SCAR=0.0
191 # the dialect can change at any time, even in the middle of a document, where subsequent keywords
192 # and vocabularies can change; however if we came to this schema via a $ref it will already be
193 # set correctly
194 6585 $state->@{qw(specification_version vocabularies)} = $state->{evaluator}->_get_metaschema_vocabulary_classes($schema->{'$schema'})->@*;
195 6585 return 1;
196 }
197  
198 604 ▶sub _traverse_keyword_anchor ($class, $schema, $state) {
Subroutine _traverse_keyword_anchor: called CC=14 SCAR=26.4
199 604 ▶ return if not assert_keyword_type($state, $schema, 'string');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "string") 0 604 604
200  
201 604 my $anchor = $schema->{$state->{keyword}};
202 return E($state, '%s value "%s" does not match required syntax', $state->{keyword}, $anchor)
203 if $state->{specification_version} =~ /^draft[467]\z/ and $anchor !~ /^#[A-Za-z][A-Za-z0-9_:.-]*\z/
204 or $state->{specification_version} eq 'draft2019-09' and $anchor !~ /^[A-Za-z][A-Za-z0-9_:.-]*\z/
205 604 ▶ or $state->{specification_version} eq 'draft2020-12' and $anchor !~ /^[A-Za-z_][A-Za-z0-9._-]*\z/;
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} =~ /^draft[467]\z/u and not $anchor =~ /^#[A-Za-z][A-Za-z0-9_:.-]*\z/u or $$state{"specification_version"} eq "draft2019-09" and not $anchor =~ /^[A-Za-z][A-Za-z0-9_:.-]*\z/u or $$state{"specification_version"} eq "draft2020-12" and not $anchor =~ /^[A-Za-z_][A-Za-z0-9._-]*\z/u 10 594 604
Condition100%15/15
$$state{"specification_version"} =~ /^draft[467]\z/u and not $anchor =~ /^#[A-Za-z][A-Za-z0-9_:.-]*\z/u or $$state{"specification_version"} eq "draft2019-09" and not $anchor =~ /^[A-Za-z][A-Za-z0-9_:.-]*\z/u or $$state{"specification_version"} eq "draft2020-12" and not $anchor =~ /^[A-Za-z_][A-Za-z0-9._-]*\z/u
l!l&&r!l&&!r
55594
$$state{"specification_version"} =~ /^draft[467]\z/u and not $anchor =~ /^#[A-Za-z][A-Za-z0-9_:.-]*\z/u or $$state{"specification_version"} eq "draft2019-09" and not $anchor =~ /^[A-Za-z][A-Za-z0-9_:.-]*\z/u
l!l&&r!l&&!r
41599
$$state{"specification_version"} =~ /^draft[467]\z/u and not $anchor =~ /^#[A-Za-z][A-Za-z0-9_:.-]*\z/u
!ll&&!rl&&r
512884
$$state{"specification_version"} eq "draft2019-09" and not $anchor =~ /^[A-Za-z][A-Za-z0-9_:.-]*\z/u
!ll&&!rl&&r
525741
$$state{"specification_version"} eq "draft2020-12" and not $anchor =~ /^[A-Za-z_][A-Za-z0-9._-]*\z/u
!ll&&!rl&&r
1624325
MC/DC83%5/6
$$state{"specification_version"} =~ /^draft[467]\z/u and not $anchor =~ /^#[A-Za-z][A-Za-z0-9_:.-]*\z/u or $$state{"specification_version"} eq "draft2019-09" and not $anchor =~ /^[A-Za-z][A-Za-z0-9_:.-]*\z/u or $$state{"specification_version"} eq "draft2020-12" and not $anchor =~ /^[A-Za-z_][A-Za-z0-9._-]*\z/u
$$state{"specification_version"} =~ /^draft[467]\z/u not $anchor =~ /^#[A-Za-z][A-Za-z0-9_:.-]*\z/u $$state{"specification_version"} eq "draft2019-09" not $anchor =~ /^[A-Za-z][A-Za-z0-9_:.-]*\z/u $$state{"specification_version"} eq "draft2020-12" not $anchor =~ /^[A-Za-z_][A-Za-z0-9._-]*\z/u
Truth table40%6/15
A and not(B) or C and not(D) or E and not(F)
A= $$state{"specification_version"} =~ /^draft[467]\z/uB= not $anchor =~ /^#[A-Za-z][A-Za-z0-9_:.-]*\z/uC= $$state{"specification_version"} eq "draft2019-09"D= not $anchor =~ /^[A-Za-z][A-Za-z0-9_:.-]*\z/uE= $$state{"specification_version"} eq "draft2020-12"F= not $anchor =~ /^[A-Za-z_][A-Za-z0-9._-]*\z/u
ABCDEFresult
11XXXX1
0X11XX1
1011XX1
0X0X111
0X10111
100X111
1010111
0X0X0X0
0X0X100
0X100X0
0X10100
100X0X0
100X100
10100X0
1010100
206  
207 594 my $canonical_uri = canonical_uri($state);
208  
209 594 ▶ $anchor =~ s/^#// if $state->{specification_version} =~ /^draft[467]\z/;
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"specification_version"} =~ /^draft[467]\z/u 88 506 594
210 594 my $uri = Mojo::URL->new->to_abs($canonical_uri)->fragment($anchor);
211 594 my $base_uri = $canonical_uri->clone->fragment(undef);
212  
213 594 ▶ if (exists $state->{identifiers}{$base_uri}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $$state{'identifiers'}{$base_uri}) { } 509 85 594
214 return E($state, 'duplicate anchor uri "%s" found (original at path "%s")',
215 $uri, $state->{identifiers}{$base_uri}{anchors}{$anchor}{path})
216 509 ▶ if exists(($state->{identifiers}{$base_uri}{anchors}//{})->{$anchor});
Branch: 1 branch
BranchTrueFalseTotal
if exists(($$state{"identifiers"}{$base_uri}{"anchors"} // {})->{$anchor}) 1 508 509
Condition100%2/2
$$state{"identifiers"}{$base_uri}{"anchors"} // {}
l!l
17492
MC/DC100%1/1
$$state{"identifiers"}{$base_uri}{"anchors"} // {}
$$state{"identifiers"}{$base_uri}{"anchors"}
Truth table100%2/2
A
A= $$state{"identifiers"}{$base_uri}{"anchors"}
Aresult
11
00
217  
218 38 ▶ use autovivification 'store';
Subroutine BEGIN: called CC=1 SCAR=0.0
219 $state->{identifiers}{$base_uri}{anchors}{$anchor} = {
220 canonical_uri => $canonical_uri,
221 path => $state->{traversed_keyword_path}.$state->{keyword_path},
222 508 };
223 }
224 # we need not be at the root of the resource schema, and we need not even have an entry
225 # in 'identifiers' for our current base uri (if there was no $id at the root, or if
226 # initial_schema_uri was overridden in the call to traverse())
227 else {
228 85 my $base_path = '';
229 85 ▶ if (my $fragment = $canonical_uri->fragment) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $fragment = $canonical_uri->fragment) 78 7 85
230 # this shouldn't happen, as we also check this at the start of traverse
231 return E($state, 'something is wrong; "%s" is not the suffix of "%s"', $fragment, $state->{traversed_keyword_path}.$state->{keyword_path})
232 78 ▶ if substr($state->{traversed_keyword_path}.$state->{keyword_path}, -length($fragment))
Branch: 1 branch
BranchTrueFalseTotal
if substr($$state{"traversed_keyword_path"} . $$state{"keyword_path"}, -length($fragment)) ne $fragment 0 78 78
233 ne $fragment;
234 78 $base_path = substr($state->{traversed_keyword_path}.$state->{keyword_path}, 0, -length($fragment));
235 }
236  
237 $state->{identifiers}{$base_uri} = {
238 # We didn't see an $id keyword at this position or above us, so a resource entry hasn't been
239 # made yet for this identifier. However, we have all the information we need to infer its
240 # data. If this entry is being created in a subschema (below the document root), another one
241 # just like it may be created by another subschema using the same base canonical uri, so that
242 # caller will need to merge the entries together before providing them to the Document's
243 # resource index.
244 canonical_uri => $base_uri,
245 path => $base_path,
246 $state->%{qw(specification_version vocabularies)},
247 anchors => {
248 $anchor => {
249 canonical_uri => $canonical_uri,
250 path => $state->{traversed_keyword_path}.$state->{keyword_path},
251 },
252 },
253 85 };
254 }
255  
256 593 return 1;
257 }
258  
259 # we already indexed the $anchor uri, so there is nothing more to do at evaluation time.
260 # we explicitly do NOT set $state->{initial_schema_uri}.
261  
262 182 ▶sub _traverse_keyword_recursiveAnchor ($class, $schema, $state) {
Subroutine _traverse_keyword_recursiveAnchor: called CC=3 SCAR=11.1
263 182 ▶ return if not assert_keyword_type($state, $schema, 'boolean');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "boolean") 0 182 182
264  
265 # this is required because the location is used as the base URI for future resolution
266 # of $recursiveRef, and the fragment would be disregarded in the base
267 return E($state, '"$recursiveAnchor" keyword used without "$id"')
268 182 ▶ if length($state->{keyword_path});
Branch: 1 branch
BranchTrueFalseTotal
if length $$state{"keyword_path"} 3 179 182
269 179 return 1;
270 }
271  
272 379 ▶sub _eval_keyword_recursiveAnchor ($class, $, $schema, $state) {
Subroutine _eval_keyword_recursiveAnchor: called CC=3 SCAR=11.0
273 379 ▶ return 1 if not $schema->{'$recursiveAnchor'} or exists $state->{recursive_anchor_uri};
Branch: 1 branch
BranchTrueFalseTotal
if not $$schema{"\$recursiveAnchor"} or exists $$state{"recursive_anchor_uri"} 303 76 379
Condition100%3/3
not $$schema{"\$recursiveAnchor"} or exists $$state{"recursive_anchor_uri"}
l!l&&r!l&&!r
5225176
MC/DC100%2/2
not $$schema{"\$recursiveAnchor"} or exists $$state{"recursive_anchor_uri"}
not $$schema{"\$recursiveAnchor"} exists $$state{"recursive_anchor_uri"}
Truth table100%3/3
not(A) or B
A= not $$schema{"\$recursiveAnchor"}B= exists $$state{"recursive_anchor_uri"}
ABresult
1X1
011
000
274  
275 # record the canonical location of the current position, to be used against future resolution
276 # of a $recursiveRef uri -- as if it was the current location when we encounter a $ref.
277 76 $state->{recursive_anchor_uri} = canonical_uri($state);
278 76 return 1;
279 }
280  
281 296 ▶sub _traverse_keyword_dynamicAnchor ($class, $schema, $state) {
Subroutine _traverse_keyword_dynamicAnchor: called CC=2 SCAR=7.2
282 296 ▶ return if not $class->_traverse_keyword_anchor($schema, $state);
Branch: 1 branch
BranchTrueFalseTotal
unless $class->_traverse_keyword_anchor($schema, $state) 0 296 296
283 296 $state->{identifiers}{$state->{initial_schema_uri}}{anchors}{$schema->{'$dynamicAnchor'}}{dynamic} = 1;
284 }
285  
286 # we already indexed the $dynamicAnchor uri, so there is nothing more to do at evaluation time.
287 # we explicitly do NOT set $state->{initial_schema_uri}.
288  
289 3703 ▶sub _traverse_keyword_ref ($class, $schema, $state) {
Subroutine _traverse_keyword_ref: called CC=6 SCAR=19.0
290 3703 ▶ return if not assert_keyword_type($state, $schema, 'string')
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "string") and assert_uri_reference($state, $schema) 32 3671 3703
Condition66%2/3
assert_keyword_type($state, $schema, "string") and assert_uri_reference($state, $schema)
!ll&&!rl&&r
0323671
MC/DC50%1/2
assert_keyword_type($state, $schema, "string") and assert_uri_reference($state, $schema)
assert_keyword_type($state, $schema, "string") assert_uri_reference($state, $schema)
Truth table66%2/3
A and B
A= assert_keyword_type($state, $schema, "string")B= assert_uri_reference($state, $schema)
ABresult
0X0
100
111
291 or not assert_uri_reference($state, $schema);
292  
293 push $state->{references}->@*, [
294 $state->{keyword},
295 ($state->{traversed_keyword_path}//'').$state->{keyword_path},
296 Mojo::URL->new($schema->{$state->{keyword}})->to_abs($state->{initial_schema_uri}//()),
297 'schema',
298 3671 ▶ ] if $state->{references};
Branch: 1 branch
BranchTrueFalseTotal
if $$state{"references"} 3090 581 3671
Condition40%2/5
$$state{"traversed_keyword_path"} // ""
l!l
30900
$$state{"initial_schema_uri"} // ()
l!l&&r!l&&!r
309000
MC/DC0%0/1
$$state{"traversed_keyword_path"} // ""
$$state{"traversed_keyword_path"}
MC/DC0%0/2
$$state{"initial_schema_uri"} // ()
$$state{"initial_schema_uri"} ()
Truth table50%1/2
A
A= $$state{"traversed_keyword_path"}
Aresult
11
00
Truth table33%1/3
A // B
A= $$state{"initial_schema_uri"}B= ()
ABresult
1X1
011
000
299  
300 3671 return 1;
301 }
302  
303 3648 ▶sub _eval_keyword_ref ($class, $data, $schema, $state) {
Subroutine _eval_keyword_ref: called CC=1 SCAR=0.0
304 3648 my $uri = Mojo::URL->new($schema->{'$ref'})->to_abs($state->{initial_schema_uri});
305 3648 $class->eval_subschema_at_uri($data, $schema, $state, $uri);
306 }
307  
308 38 *_traverse_keyword_recursiveRef = \&_traverse_keyword_ref;
309  
310 108 ▶sub _eval_keyword_recursiveRef ($class, $data, $schema, $state) {
Subroutine _eval_keyword_recursiveRef: called CC=7 SCAR=19.6
311 108 my $uri = Mojo::URL->new($schema->{'$recursiveRef'})->to_abs($state->{initial_schema_uri});
312 108 my $schema_info = $state->{evaluator}->_fetch_from_uri($uri);
313 108 ▶ abort($state, 'EXCEPTION: unable to find resource "%s"', $uri) if not $schema_info;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema_info 0 108 108
314 abort($state, 'EXCEPTION: bad reference to "%s": not a schema', $schema_info->{canonical_uri})
315 108 ▶ if $schema_info->{document}->get_entity_at_location($schema_info->{document_path}) ne 'schema';
Branch: 1 branch
BranchTrueFalseTotal
if $$schema_info{"document"}->get_entity_at_location($$schema_info{"document_path"}) ne "schema" 1 107 108
316  
317 107 ▶ if (ref $schema_info->{schema} eq 'HASH'
Branch: 1 branch
BranchTrueFalseTotal
if (ref $$schema_info{"schema"} eq "HASH" and is_type("boolean", $$schema_info{"schema"}{"\$recursiveAnchor"}) and $$schema_info{"schema"}{"\$recursiveAnchor"}) 62 45 107
Condition100%6/6
ref $$schema_info{"schema"} eq "HASH" and is_type("boolean", $$schema_info{"schema"}{"\$recursiveAnchor"}) and $$schema_info{"schema"}{"\$recursiveAnchor"}
!ll&&!rl&&r
212462
ref $$schema_info{"schema"} eq "HASH" and is_type("boolean", $$schema_info{"schema"}{"\$recursiveAnchor"})
!ll&&!rl&&r
41786
MC/DC100%3/3
ref $$schema_info{"schema"} eq "HASH" and is_type("boolean", $$schema_info{"schema"}{"\$recursiveAnchor"}) and $$schema_info{"schema"}{"\$recursiveAnchor"}
ref $$schema_info{"schema"} eq "HASH" is_type("boolean", $$schema_info{"schema"}{"\$recursiveAnchor"}) $$schema_info{"schema"}{"\$recursiveAnchor"}
Truth table100%4/4
A and B and C
A= ref $$schema_info{"schema"} eq "HASH"B= is_type("boolean", $$schema_info{"schema"}{"\$recursiveAnchor"})C= $$schema_info{"schema"}{"\$recursiveAnchor"}
ABCresult
0XX0
10X0
1100
1111
318 and is_type('boolean', $schema_info->{schema}{'$recursiveAnchor'})
319 and $schema_info->{schema}{'$recursiveAnchor'}) {
320 $uri = Mojo::URL->new($schema->{'$recursiveRef'})
321 62 ▶ ->to_abs($state->{recursive_anchor_uri} // $state->{initial_schema_uri});
Condition33%1/3
$$state{"recursive_anchor_uri"} // $$state{"initial_schema_uri"}
l!l&&r!l&&!r
6200
MC/DC0%0/2
$$state{"recursive_anchor_uri"} // $$state{"initial_schema_uri"}
$$state{"recursive_anchor_uri"} $$state{"initial_schema_uri"}
Truth table33%1/3
A // B
A= $$state{"recursive_anchor_uri"}B= $$state{"initial_schema_uri"}
ABresult
1X1
011
000
322 }
323  
324 107 return $class->eval_subschema_at_uri($data, $schema, $state, $uri);
325 }
326  
327 38 *_traverse_keyword_dynamicRef = \&_traverse_keyword_ref;
328  
329 214 ▶sub __resolve_dynamicRef ($class, $uri, $state) {
Subroutine __resolve_dynamicRef: called CC=12 SCAR=24.9
330 214 $uri = Mojo::URL->new($uri)->to_abs($state->{initial_schema_uri});
331 214 my $schema_info = $state->{evaluator}->_fetch_from_uri($uri);
332 214 ▶ abort($state, 'EXCEPTION: unable to find resource "%s"', $uri) if not $schema_info;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema_info 0 214 214
333 abort($state, 'EXCEPTION: bad reference to "%s": not a schema', $schema_info->{canonical_uri})
334 214 ▶ if $schema_info->{document}->get_entity_at_location($schema_info->{document_path}) ne 'schema';
Branch: 1 branch
BranchTrueFalseTotal
if $$schema_info{"document"}->get_entity_at_location($$schema_info{"document_path"}) ne "schema" 1 213 214
335  
336 # If the initially resolved starting point URI includes a fragment that was created by the
337 # "$dynamicAnchor" keyword, ...
338 213 ▶ if (length $uri->fragment
Branch: 1 branch
BranchTrueFalseTotal
if (length $uri->fragment and ref $$schema_info{"schema"} eq "HASH" and exists $$schema_info{"schema"}{"\$dynamicAnchor"} and $uri->fragment eq (my $anchor = $$schema_info{"schema"}{"\$dynamicAnchor"})) 175 38 213
Condition100%9/9
length $uri->fragment and ref $$schema_info{"schema"} eq "HASH" and exists $$schema_info{"schema"}{"\$dynamicAnchor"} and $uri->fragment eq (my $anchor = $$schema_info{"schema"}{"\$dynamicAnchor"})
!ll&&!rl&&r
2711175
length $uri->fragment and ref $$schema_info{"schema"} eq "HASH" and exists $$schema_info{"schema"}{"\$dynamicAnchor"}
!ll&&!rl&&r
1314186
length $uri->fragment and ref $$schema_info{"schema"} eq "HASH"
!ll&&!rl&&r
58200
MC/DC100%4/4
length $uri->fragment and ref $$schema_info{"schema"} eq "HASH" and exists $$schema_info{"schema"}{"\$dynamicAnchor"} and $uri->fragment eq (my $anchor = $$schema_info{"schema"}{"\$dynamicAnchor"})
length $uri->fragment ref $$schema_info{"schema"} eq "HASH" exists $$schema_info{"schema"}{"\$dynamicAnchor"} $uri->fragment eq (my $anchor = $$schema_info{"schema"}{"\$dynamicAnchor"})
Truth table100%5/5
A and B and C and D
A= length $uri->fragmentB= ref $$schema_info{"schema"} eq "HASH"C= exists $$schema_info{"schema"}{"\$dynamicAnchor"}D= $uri->fragment eq (my $anchor = $$schema_info{"schema"}{"\$dynamicAnchor"})
ABCDresult
0XXX0
10XX0
110X0
11100
11111
339 and ref $schema_info->{schema} eq 'HASH'
340 and exists $schema_info->{schema}{'$dynamicAnchor'}
341 and $uri->fragment eq (my $anchor = $schema_info->{schema}{'$dynamicAnchor'})) {
342 # ...the initial URI MUST be replaced by the URI (including the fragment) for the outermost
343 # schema resource in the dynamic scope that defines an identically named fragment with
344 # "$dynamicAnchor".
345 175 foreach my $scope_uri ($state->{dynamic_scope}->@*) {
346 234 my $resource = $state->{evaluator}->_get_or_load_resource($scope_uri);
347 234 ▶ die 'bad dynamic scope uri: ', $scope_uri if not $resource;
Branch: 1 branch
BranchTrueFalseTotal
unless $resource 0 234 234
348 234 ▶ if (exists(($resource->{anchors}//{})->{$anchor}) and $resource->{anchors}{$anchor}{dynamic}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists(($$resource{"anchors"} // {})->{$anchor}) and $$resource{"anchors"}{$anchor}{"dynamic"}) 170 64 234
Condition100%5/5
exists(($$resource{"anchors"} // {})->{$anchor}) and $$resource{"anchors"}{$anchor}{"dynamic"}
!ll&&!rl&&r
5410170
$$resource{"anchors"} // {}
l!l
18153
MC/DC100%2/2
exists(($$resource{"anchors"} // {})->{$anchor}) and $$resource{"anchors"}{$anchor}{"dynamic"}
$$resource{"anchors"} $$resource{"anchors"}{$anchor}{"dynamic"}
Truth table100%3/3
A and B
A= $$resource{"anchors"}B= $$resource{"anchors"}{$anchor}{"dynamic"}
ABresult
0X0
100
111
349 170 $uri = Mojo::URL->new($scope_uri)->fragment($anchor);
350 170 last;
351 }
352 }
353 }
354  
355 213 return $uri;
356 }
357  
358 214 ▶sub _eval_keyword_dynamicRef ($class, $data, $schema, $state) {
Subroutine _eval_keyword_dynamicRef: called CC=1 SCAR=0.0
359 214 my $uri = $class->__resolve_dynamicRef($schema->{'$dynamicRef'}, $state);
360 213 return $class->eval_subschema_at_uri($data, $schema, $state, $uri);
361 }
362  
363 102 ▶sub _traverse_keyword_vocabulary ($class, $schema, $state) {
Subroutine _traverse_keyword_vocabulary: called CC=6 SCAR=17.9
364 102 ▶ return if not assert_keyword_type($state, $schema, 'object');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "object") 0 102 102
365  
366 return E($state, '$vocabulary can only appear at the schema resource root')
367 102 ▶ if length($state->{keyword_path});
Branch: 1 branch
BranchTrueFalseTotal
if length $$state{"keyword_path"} 1 101 102
368  
369 101 my $valid = 1;
370  
371 101 my @vocabulary_classes;
372 101 foreach my $uri (sort keys $schema->{'$vocabulary'}->%*) {
373 249 ▶ if (not is_type('boolean', $schema->{'$vocabulary'}{$uri})) {
Branch: 1 branch
BranchTrueFalseTotal
unless (is_type("boolean", $$schema{"\$vocabulary"}{$uri})) 5 244 249
374 5 ()= E({ %$state, _keyword_path_suffix => $uri }, '$vocabulary value at "%s" is not a boolean', $uri);
375 5 $valid = 0;
376 5 next;
377 }
378  
379 244 ▶ $valid = 0 if not assert_uri({ %$state, _keyword_path_suffix => $uri }, undef, $uri);
Branch: 1 branch
BranchTrueFalseTotal
unless assert_uri({%$state, "_keyword_path_suffix", $uri}, undef, $uri) 13 231 244
380 }
381  
382 # we cannot return an error here for invalid or incomplete vocabulary lists, because
383 # - the specification vocabulary schemas themselves don't list Core,
384 # - it is possible for a metaschema to $ref to another metaschema that uses an unrecognized
385 # vocabulary uri while still validating those vocabulary keywords (e.g.
386 # https://spec.openapis.org/oas/3.1/schema-base/2021-05-20)
387 # Instead, we will verify these constraints when we actually use the metaschema, in
388 # _traverse_keyword_schema -> _fetch_vocabulary_data
389  
390 101 return $valid;
391 }
392  
393 # we do nothing with $vocabulary yet at evaluation time. When we know we are in a metaschema,
394 # we can scan the URIs included here and either abort if a vocabulary is enabled that we do not
395 # understand, or turn on and off certain keyword behaviours based on the boolean values seen.
396  
397 662 ▶sub _traverse_keyword_comment ($class, $schema, $state) {
Subroutine _traverse_keyword_comment: called CC=2 SCAR=7.2
398 662 ▶ return if not assert_keyword_type($state, $schema, 'string');
Branch: 1 branch
BranchTrueFalseTotal
unless assert_keyword_type($state, $schema, "string") 0 662 662
399 662 return 1;
400 }
401  
402 # we do nothing with $comment at evaluation time, including not collecting its value for annotations.
403  
404 593 ▶sub _traverse_keyword_definitions { shift->traverse_object_schemas(@_) }
Subroutine _traverse_keyword_definitions: called CC=1 SCAR=0.0
405 1125 ▶sub _traverse_keyword_defs { shift->traverse_object_schemas(@_) }
Subroutine _traverse_keyword_defs: called CC=1 SCAR=0.0
406  
407 # we do nothing directly with $defs at evaluation time, including not collecting its value for
408 # annotations.
409  
410 38 1;
411  
412 __END__
« Modern/Vocabulary/Unevaluated.pm ↑ Summary Modern/Vocabulary/Validation.pm »