lib/IO/K8s/CRD.pm

filter: Statementstmt 98.3% 293 / 298 Branchbran 92.2% 201 / 218 Conditioncond 63.2% 43 / 68 MC/DCmcdc 35.0% 14 / 40 Subroutinesub 100% 27 / 27 Podpod 100% 5 / 5 totaltotal 88.8% 583 / 656 CC 140 SCAR 28.0
CC
140
Cov
92%
_type_schema
32.4
_pattern_to_ecma262
25.4
load
18.1
CRAP 16.4
« lib/IO/K8s/Role/Routable.pm ↑ Summary blib/lib/IO/K8s/APIObject.pm »
1 package IO::K8s::CRD;
2 # ABSTRACT: Turn CustomResourceDefinition manifests into IO::K8s classes
3 31 our $VERSION = '1.112';
4 31 ▶use v5.10;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 31 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 31 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
7 31 ▶use Carp qw( croak );
Subroutine BEGIN: called CC=1 SCAR=0.0
8 31 ▶use Scalar::Util qw( blessed );
Subroutine BEGIN: called CC=1 SCAR=0.0
9 31 ▶use Module::Runtime qw( require_module );
Subroutine BEGIN: called CC=1 SCAR=0.0
10 31 ▶use JSON::MaybeXS ();
Subroutine BEGIN: called CC=1 SCAR=0.0
11 31 ▶use re ();
Subroutine BEGIN: called CC=1 SCAR=0.0
12 31 ▶use IO::K8s ();
Subroutine BEGIN: called CC=1 SCAR=0.0
13 31 ▶use IO::K8s::AutoGen ();
Subroutine BEGIN: called CC=1 SCAR=0.0
14 31 ▶use IO::K8s::Resource ();
Subroutine BEGIN: called CC=1 SCAR=0.0
15  
16 # Carp treats the distribution modules this one works with on a public path
17 # as part of it, so an error names the line that called into them:
18 # * IO::K8s (k165): a croak from load or generate reached through
19 # IO::K8s->add_crd names the line that called add_crd, not add_crd's
20 # own line in lib/IO/K8s.pm, and the "Cannot open" IO::K8s->_slurp_utf8
21 # raises for load names load's caller, not this file;
22 # * IO::K8s::AutoGen (k170): a croak from class generation under generate
23 # -- directly or through add_crd, the first failure and the remembered
24 # one AutoGen rethrows for a later request (k149) -- names the caller,
25 # not the generate line here;
26 # * IO::K8s::Role::APIObject (k170): a croak from crd_for_class reached
27 # through $class->to_crd names the line that called to_crd, not the
28 # to_crd line in lib/IO/K8s/Role/APIObject.pm.
29 # A caller in any other package still sees its own line.
30 31 our @CARP_NOT = ('IO::K8s', 'IO::K8s::AutoGen', 'IO::K8s::Role::APIObject');
31  
32 # The typed class crd_for_class() and new() build and return (D9). Kept as
33 # a constant rather than spelled out at each call site -- the brief's own
34 # shorthand ('IO::K8s::Apiextensions::Pkg::...') drops the
35 # 'ApiextensionsApiserver' segment the shipped classes actually use; this
36 # is the real, checked-in name (see lib/IO/K8s/ApiextensionsApiserver/).
37 31 my $CRD_CLASS = 'IO::K8s::ApiextensionsApiserver::Pkg::Apis::Apiextensions::V1::CustomResourceDefinition';
38  
39  
40  
41 79 ▶sub load {
Subroutine load: called CC=17 SCAR=29.0
Pod documented
42 79 my ($class, $input) = @_;
43 79 ▶ croak 'IO::K8s::CRD->load needs a CustomResourceDefinition object, a hashref, YAML/JSON text or a file path'
Branch: 1 branch
BranchTrueFalseTotal
unless defined $input 1 78 79
44 unless defined $input;
45  
46 78 my @docs;
47 78 ▶ if (ref $input eq 'ARRAY') {
Branch: 4 branches
BranchTrueFalseTotal
if (ref $input eq 'ARRAY') { } 2 76 78
elsif (builtin::blessed($input) and $input->can('TO_JSON')) { } 4 72 76
elsif (ref $input eq 'HASH') { } 19 53 72
elsif (not ref $input) { } 53 0 53
48 2 return [ map { @{ $class->load($_) } } @$input ];
49 }
50 ▶ elsif (blessed($input) && $input->can('TO_JSON')) {
Condition66%2/3
builtin::blessed($input) and $input->can("TO_JSON")
!ll&&!rl&&r
7204
MC/DC50%1/2
builtin::blessed($input) and $input->can("TO_JSON")
builtin::blessed($input) $input->can("TO_JSON")
Truth table66%2/3
A and B
A= builtin::blessed($input)B= $input->can("TO_JSON")
ABresult
0X0
100
111
51 4 @docs = ($input->TO_JSON);
52 }
53 elsif (ref $input eq 'HASH') {
54 19 @docs = ($input);
55 }
56 elsif (!ref $input) {
57 # A file or YAML text by load_yaml's rule (k162): a file is read as
58 # UTF-8, a directory is refused, and a one-line argument that is no
59 # file and only parses to plain scalars -- a mistyped path -- dies
60 # instead of giving [] and an add_crd that registers nothing.
61 53 my ($refused, @found) = IO::K8s->_yaml_documents($input, IO::K8s->_yaml_parser('JSON::PP'));
62 51 ▶ croak "IO::K8s::CRD->load: '".$input."' ".$refused if defined $refused;
Branch: 1 branch
BranchTrueFalseTotal
if defined $refused 9 42 51
63 42 @docs = grep { ref $_ eq 'HASH' } @found;
64 }
65 else {
66 0 croak 'IO::K8s::CRD->load: unsupported input ' . ref($input);
67 }
68  
69 65 for my $i (0 .. $#docs) {
70 57 my $doc = $docs[$i];
71 57 ▶ my $kind = $doc->{kind} // '';
Condition50%1/2
$doc->{"kind"} // ""
l!l
570
MC/DC0%0/1
$doc->{"kind"} // ""
$doc->{"kind"}
Truth table50%1/2
A
A= $doc->{"kind"}
Aresult
11
00
72 57 ▶ croak 'IO::K8s::CRD->load: document ' . ($i + 1) . " is a '$kind', not a CustomResourceDefinition"
Branch: 1 branch
BranchTrueFalseTotal
unless $kind eq "CustomResourceDefinition" 3 54 57
73 unless $kind eq 'CustomResourceDefinition';
74 croak 'IO::K8s::CRD->load: CustomResourceDefinition without spec.group / spec.names.kind / spec.versions'
75 unless ref $doc->{spec} eq 'HASH'
76 && defined $doc->{spec}{group}
77 && ref $doc->{spec}{names} eq 'HASH' && defined $doc->{spec}{names}{kind}
78 54 ▶ && ref $doc->{spec}{versions} eq 'ARRAY' && @{ $doc->{spec}{versions} };
Branch: 1 branch
BranchTrueFalseTotal
unless ref $doc->{"spec"} eq "HASH" and defined $doc->{"spec"}{"group"} and ref $doc->{"spec"}{"names"} eq "HASH" and defined $doc->{"spec"}{"names"}{"kind"} and ref $doc->{"spec"}{"versions"} eq "ARRAY" and @{$doc->{"spec"}{"versions"};} 2 52 54
Condition66%10/15
ref $doc->{"spec"} eq "HASH" and defined $doc->{"spec"}{"group"} and ref $doc->{"spec"}{"names"} eq "HASH" and defined $doc->{"spec"}{"names"}{"kind"} and ref $doc->{"spec"}{"versions"} eq "ARRAY" and @{$doc->{"spec"}{"versions"};}
!ll&&!rl&&r
1152
ref $doc->{"spec"} eq "HASH" and defined $doc->{"spec"}{"group"} and ref $doc->{"spec"}{"names"} eq "HASH" and defined $doc->{"spec"}{"names"}{"kind"} and ref $doc->{"spec"}{"versions"} eq "ARRAY"
!ll&&!rl&&r
1053
ref $doc->{"spec"} eq "HASH" and defined $doc->{"spec"}{"group"} and ref $doc->{"spec"}{"names"} eq "HASH" and defined $doc->{"spec"}{"names"}{"kind"}
!ll&&!rl&&r
1053
ref $doc->{"spec"} eq "HASH" and defined $doc->{"spec"}{"group"} and ref $doc->{"spec"}{"names"} eq "HASH"
!ll&&!rl&&r
0153
ref $doc->{"spec"} eq "HASH" and defined $doc->{"spec"}{"group"}
!ll&&!rl&&r
0054
MC/DC33%2/6
ref $doc->{"spec"} eq "HASH" and defined $doc->{"spec"}{"group"} and ref $doc->{"spec"}{"names"} eq "HASH" and defined $doc->{"spec"}{"names"}{"kind"} and ref $doc->{"spec"}{"versions"} eq "ARRAY" and @{$doc->{"spec"}{"versions"};}
ref $doc->{"spec"} eq "HASH" defined $doc->{"spec"}{"group"} ref $doc->{"spec"}{"names"} eq "HASH" defined $doc->{"spec"}{"names"}{"kind"} ref $doc->{"spec"}{"versions"} eq "ARRAY" @{$doc->{"spec"}{"versions"};}
Truth table42%3/7
A and B and C and D and E and F
A= ref $doc->{"spec"} eq "HASH"B= defined $doc->{"spec"}{"group"}C= ref $doc->{"spec"}{"names"} eq "HASH"D= defined $doc->{"spec"}{"names"}{"kind"}E= ref $doc->{"spec"}{"versions"} eq "ARRAY"F= @{$doc->{"spec"}{"versions"};}
ABCDEFresult
0XXXXX0
10XXXX0
110XXX0
1110XX0
11110X0
1111100
1111111
79 }
80 60 return \@docs;
81 }
82  
83 # served / storage arrive as JSON booleans, plain 0/1, or the strings a
84 # hand-written YAML may carry; the DSL's one boolean normalization decides.
85 # A missing field is a legitimate "not set" and stays 0/false; a field that
86 # IS present but cannot mean true or false (an arrayref, say) must not be
87 # swallowed into the same "not set" answer -- croak instead, naming the
88 # version index and field so the manifest is easy to find.
89 172 ▶sub _flag {
Subroutine _flag: called CC=4 SCAR=13.9
90 172 my ($value, $field, $index) = @_;
91 172 ▶ return 0 unless defined $value;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $value 0 172 172
92 172 my $bool = eval { IO::K8s::Resource::_normalize_bool($value) };
93 172 ▶ croak "IO::K8s::CRD: spec.versions[$index].$field is not a boolean" if $@;
Branch: 1 branch
BranchTrueFalseTotal
if $@ 3 169 172
94 169 ▶ return $bool ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$bool ? : 126 43 169
95 }
96  
97  
98 53 ▶sub served_versions {
Subroutine served_versions: called CC=7 SCAR=19.5
Pod documented
99 53 my ($class, $crd) = @_;
100 53 my $group = $crd->{spec}{group};
101 53 my $versions = $crd->{spec}{versions};
102 53 my @out;
103 53 for my $i (0 .. $#$versions) {
104 95 my $v = $versions->[$i];
105 95 ▶ next unless _flag($v->{served}, 'served', $i);
Branch: 1 branch
BranchTrueFalseTotal
unless _flag($v->{"served"}, "served", $i) 15 77 92
106 push @out, {
107 name => $v->{name},
108 api_version => "$group/$v->{name}",
109 storage => _flag($v->{storage}, 'storage', $i),
110 # A plain '$v->{schema}{openAPIV3Schema}' would autovivify
111 # $v->{schema} into {} on a version that has none, silently
112 # mutating the caller's manifest hashref -- ref() first, so a
113 # missing/undef 'schema' is read without creating it.
114 schema => (ref $v->{schema} eq 'HASH' ? $v->{schema}{openAPIV3Schema} : undef) // { type => 'object' },
115 # As given, only when the version has any (k158): generate
116 # hands it to the class, which checks it.
117 77 ▶ (defined $v->{subresources} ? (subresources => $v->{subresources}) : ()),
Branch: 2 branches
BranchTrueFalseTotal
ref $v->{'schema'} eq 'HASH' ? : 76 1 77
defined $v->{'subresources'} ? : 26 51 77
Condition100%2/2
(ref $v->{"schema"} eq "HASH" ? $v->{"schema"}{"openAPIV3Schema"} : undef) // {"type", "object"}
l!l
761
MC/DC100%1/1
(ref $v->{"schema"} eq "HASH" ? $v->{"schema"}{"openAPIV3Schema"} : undef) // {"type", "object"}
(ref $v->{"schema"} eq "HASH" ? $v->{"schema"}{"openAPIV3Schema"} : undef)
Truth table100%2/2
A
A= (ref $v->{"schema"} eq "HASH" ? $v->{"schema"}{"openAPIV3Schema"} : undef)
Aresult
11
00
118 };
119 }
120 50 ▶ croak "IO::K8s::CRD: no served version in the CRD for $crd->{spec}{names}{kind}" unless @out;
Branch: 1 branch
BranchTrueFalseTotal
unless @out 0 50 50
121 50 return \@out;
122 }
123  
124  
125 48 ▶sub generate {
Subroutine generate: called CC=7 SCAR=19.5
Pod documented
126 48 my ($class, $crd, $namespace, %opts) = @_;
127 48 my $spec = $crd->{spec};
128 48 my $group = $spec->{group};
129 48 my $kind = $spec->{names}{kind};
130 48 ▶ my $namespaced = ($spec->{scope} // 'Namespaced') eq 'Namespaced' ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
($spec->{'scope'} // 'Namespaced') eq 'Namespaced' ? : 47 1 48
Condition100%2/2
$spec->{"scope"} // "Namespaced"
l!l
462
MC/DC100%1/1
$spec->{"scope"} // "Namespaced"
$spec->{"scope"}
Truth table100%2/2
A
A= $spec->{"scope"}
Aresult
11
00
131  
132 # See the POD above: a sub-namespace of our own so a CRD-derived class
133 # can never alias with one AutoGen would build straight from an
134 # openapi_spec definition of the same GVK under the caller's namespace.
135 48 my $crd_namespace = "$namespace\::_CRD";
136  
137 48 my %out;
138 my $fallback;
139 48 for my $v (@{ $class->served_versions($crd) }) {
140 67 my $def_name = join '.', $group, $v->{name}, $kind;
141 my $schema = {
142 67 %{ $v->{schema} },
143 67 'x-kubernetes-group-version-kind' => [ { group => $group, version => $v->{name}, kind => $kind } ],
144 };
145 $out{ $v->{api_version} } = IO::K8s::AutoGen::get_or_generate(
146 $def_name, $schema, {}, $crd_namespace,
147 api_version => $v->{api_version},
148 kind => $kind,
149 resource_plural => $spec->{names}{plural},
150 is_namespaced => $namespaced,
151 67 ▶ (exists $v->{subresources} ? (subresources => $v->{subresources}) : ()),
Branch: 1 branch
BranchTrueFalseTotal
exists $v->{'subresources'} ? : 22 45 67
152 %opts,
153 );
154 # Track every served version as the fallback so the LAST one wins
155 # when none is marked storage -- matching the POD above. An explicit
156 # storage:true always overrides it, regardless of position.
157 63 $fallback = $v->{api_version};
158 63 ▶ $out{storage} = $v->{api_version} if $v->{storage};
Branch: 1 branch
BranchTrueFalseTotal
if $v->{"storage"} 41 22 63
159 }
160 42 ▶ $out{storage} //= $fallback;
Condition66%2/3
$out{"storage"} //= $fallback
l!l&&r!l&&!r
4110
MC/DC0%0/2
$out{"storage"} //= $fallback
$out{"storage"} $fallback
Truth table66%2/3
A //= B
A= $out{"storage"}B= $fallback
ABresult
1X1
011
000
161 42 return \%out;
162 }
163  
164  
165 292 ▶sub crd_for_class {
Subroutine crd_for_class: called CC=3 SCAR=12.0
Pod documented
166 292 my ($class) = @_;
167 292 ▶ croak 'IO::K8s::CRD::crd_for_class needs a class name' unless defined $class && length $class;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $class and length $class 0 292 292
Condition33%1/3
defined $class and length $class
!ll&&!rl&&r
00292
MC/DC0%0/2
defined $class and length $class
defined $class length $class
Truth table33%1/3
A and B
A= defined $classB= length $class
ABresult
0X0
100
111
168  
169 292 my $id = _identity_for_class($class);
170 292 return __PACKAGE__->new(classes => [$class], storage => $id->{version});
171 }
172  
173  
174 307 ▶sub new {
Subroutine new: called CC=13 SCAR=25.7
Pod documented
175 307 my ($invocant, %args) = @_;
176  
177 307 my $classes = $args{classes};
178 307 ▶ croak "IO::K8s::CRD->new needs a non-empty 'classes' arrayref"
Branch: 1 branch
BranchTrueFalseTotal
unless ref $classes eq "ARRAY" and @$classes 1 306 307
Condition66%2/3
ref $classes eq "ARRAY" and @$classes
!ll&&!rl&&r
01306
MC/DC50%1/2
ref $classes eq "ARRAY" and @$classes
ref $classes eq "ARRAY" @$classes
Truth table66%2/3
A and B
A= ref $classes eq "ARRAY"B= @$classes
ABresult
0X0
100
111
179 unless ref $classes eq 'ARRAY' && @$classes;
180  
181 my @ids = map {
182 306 _ensure_class_loaded($_);
183 322 _identity_for_class($_);
184 } @$classes;
185  
186 306 for my $field (qw(group kind plural scope)) {
187 1218 my %by_value;
188 1218 push @{ $by_value{ $ids[$_]{$field} } }, $classes->[$_] for 0 .. $#ids;
189 1218 ▶ next if keys %by_value <= 1;
Branch: 1 branch
BranchTrueFalseTotal
if keys %by_value <= 1 1214 4 1218
190 croak "IO::K8s::CRD->new: classes disagree on $field ("
191 4 . join(', ', map { "$_: " . join(',', @{ $by_value{$_} }) } sort keys %by_value)
192 . ") -- classes passed to ->new must all be versions of the same CRD";
193 }
194  
195 302 my %seen_version;
196 302 my @dupes = grep { $seen_version{$_}++ } map { $_->{version} } @ids;
197 302 ▶ croak "IO::K8s::CRD->new: duplicate version name(s) (@dupes) across classes; "
Branch: 1 branch
BranchTrueFalseTotal
if @dupes 1 301 302
198 . "each class must be a distinct served version"
199 if @dupes;
200  
201 301 my $storage = $args{storage};
202 301 ▶ croak "IO::K8s::CRD->new needs a 'storage' version name" unless defined $storage && length $storage;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $storage and length $storage 1 300 301
Condition66%2/3
defined $storage and length $storage
!ll&&!rl&&r
10300
MC/DC50%1/2
defined $storage and length $storage
defined $storage length $storage
Truth table66%2/3
A and B
A= defined $storageB= length $storage
ABresult
0X0
100
111
203 300 my ($storage_index) = grep { $ids[$_]{version} eq $storage } 0 .. $#ids;
204 croak "IO::K8s::CRD->new: storage '$storage' does not name any of the given classes' versions ("
205 300 ▶ . join(', ', map { $_->{version} } @ids) . ")"
Branch: 1 branch
BranchTrueFalseTotal
unless defined $storage_index 1 299 300
206 unless defined $storage_index;
207  
208 299 my $id0 = $ids[0];
209 my @versions = map {
210 299 my $i = $_;
211 309 ▶ my $subresources = $classes->[$i]->can('subresources') && $classes->[$i]->subresources;
Condition66%2/3
$classes->[$i]->can('subresources') && $classes->[$i]->subresources
!ll&&!rl&&r
1710138
MC/DC50%1/2
$classes->[$i]->can('subresources') && $classes->[$i]->subresources
$classes->[$i]->can('subresources') $classes->[$i]->subresources
Truth table66%2/3
A && B
A= $classes->[$i]->can('subresources')B= $classes->[$i]->subresources
ABresult
0X0
100
111
212 {
213 name => $ids[$i]{version},
214 309 ▶ served => JSON::MaybeXS::true,
Branch: 2 branches
BranchTrueFalseTotal
$i == $storage_index ? : 299 10 309
$subresources ? : 138 168 306
215 storage => ($i == $storage_index) ? JSON::MaybeXS::true : JSON::MaybeXS::false,
216 schema => { openAPIV3Schema => _schema_for_class($classes->[$i]) },
217 # Per version, the way the apiserver takes them: each class's
218 # own declaration (k158), no key for a class without one.
219 ($subresources ? (subresources => $subresources) : ()),
220 };
221 } 0 .. $#ids;
222  
223 my $manifest = {
224 metadata => { name => "$id0->{plural}.$id0->{group}" },
225 spec => {
226 group => $id0->{group},
227 scope => $id0->{scope},
228 names => {
229 plural => $id0->{plural},
230 kind => $id0->{kind},
231 296 singular => lc($id0->{kind}),
232 listKind => "$id0->{kind}List",
233 },
234 versions => \@versions,
235 },
236 };
237  
238 296 require IO::K8s;
239 296 my $k8s = IO::K8s->new;
240 296 return $k8s->_struct_to_object_expanded($CRD_CLASS, $manifest);
241 }
242  
243 # Shared by crd_for_class and new(): $class's group/version (split out of
244 # api_version), kind, resource_plural and Namespaced-or-Cluster scope --
245 # everything both need to know about $class besides its schema. Does not
246 # call _ensure_class_loaded itself (callers that need it call that first;
247 # crd_for_class historically didn't, and to_crd's caller is always already
248 # loaded), so this keeps crd_for_class's pre-existing behaviour unchanged
249 # for an unloaded class: a plain "Can't locate object method" from Perl,
250 # not a custom message.
251 614 ▶sub _identity_for_class {
Subroutine _identity_for_class: called CC=7 SCAR=20.5
252 614 my ($class) = @_;
253  
254 614 my $api_version = $class->api_version;
255 614 my ($group, $version) = $api_version =~ m{\A(?:(.*)/)?([^/]+)\z};
256 614 ▶ croak "IO::K8s::CRD: cannot read a version out of "
Branch: 1 branch
BranchTrueFalseTotal
unless defined $version and length $version 0 614 614
Condition33%1/3
defined $version and length $version
!ll&&!rl&&r
00614
MC/DC0%0/2
defined $version and length $version
defined $version length $version
Truth table33%1/3
A and B
A= defined $versionB= length $version
ABresult
0X0
100
111
257 . "'$api_version' (from ${class}->api_version)"
258 unless defined $version && length $version;
259 614 ▶ $group = '' unless defined $group;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $group 34 580 614
260  
261 614 my $kind = $class->kind;
262 614 my $plural = $class->resource_plural;
263 614 ▶ croak "IO::K8s::CRD: $class has no resource_plural"
Branch: 1 branch
BranchTrueFalseTotal
unless defined $plural and length $plural 0 614 614
Condition33%1/3
defined $plural and length $plural
!ll&&!rl&&r
00614
MC/DC0%0/2
defined $plural and length $plural
defined $plural length $plural
Truth table33%1/3
A and B
A= defined $pluralB= length $plural
ABresult
0X0
100
111
264 unless defined $plural && length $plural;
265  
266 614 ▶ my $scope = $class->DOES('IO::K8s::Role::Namespaced') ? 'Namespaced' : 'Cluster';
Branch: 1 branch
BranchTrueFalseTotal
$class->DOES('IO::K8s::Role::Namespaced') ? : 361 253 614
267  
268 614 return { group => $group, version => $version, kind => $kind, plural => $plural, scope => $scope };
269 }
270  
271  
272 10455 ▶sub _schema_for_class {
Subroutine _schema_for_class: called CC=11 SCAR=24.0
273 10455 my ($class, $seen) = @_;
274 10455 ▶ $seen ||= {};
Condition100%2/2
$seen ||= {}
l!l
10062393
MC/DC100%1/1
$seen ||= {}
$seen
Truth table100%2/2
A
A= $seen
Aresult
11
00
275 10455 ▶ return _opaque_object() if $seen->{$class};
Branch: 1 branch
BranchTrueFalseTotal
if $seen->{$class} 10 10445 10455
276  
277 10445 _ensure_class_loaded($class);
278 10445 my $info = $class->_k8s_attr_info;
279 10445 ▶ my $is_top = $class->can('_is_resource') ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$class->can('_is_resource') ? : 344 10101 10445
280 10445 my %next_seen = (%$seen, $class => 1);
281  
282 10445 my (%properties, @required);
283 10445 for my $attr (sort keys %$info) {
284 37231 ▶ next if $is_top && $attr eq 'metadata';
Branch: 1 branch
BranchTrueFalseTotal
if $is_top and $attr eq "metadata" 344 36887 37231
Condition100%3/3
$is_top and $attr eq "metadata"
!ll&&!rl&&r
36213674344
MC/DC100%2/2
$is_top and $attr eq "metadata"
$is_top $attr eq "metadata"
Truth table100%3/3
A and B
A= $is_topB= $attr eq "metadata"
ABresult
0X0
100
111
285 36887 my $entry = $info->{$attr};
286 36887 ▶ my $json_key = $entry->{json_key} // $attr;
Condition66%2/3
$entry->{"json_key"} // $attr
l!l&&r!l&&!r
105367820
MC/DC0%0/2
$entry->{"json_key"} // $attr
$entry->{"json_key"} $attr
Truth table66%2/3
A // B
A= $entry->{"json_key"}B= $attr
ABresult
1X1
011
000
287 36887 $properties{$json_key} = _property_schema($entry, \%next_seen, $class . '.' . $json_key);
288 36877 ▶ push @required, $json_key if $entry->{required};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"required"} 8716 28161 36877
289 }
290  
291 10435 ▶ if ($is_top) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_top) 341 10094 10435
292 341 $properties{apiVersion} = { type => 'string' };
293 341 $properties{kind} = { type => 'string' };
294 341 $properties{metadata} = { type => 'object' };
295 }
296  
297 10435 my %schema = (type => 'object', properties => \%properties);
298 10435 ▶ $schema{required} = [ sort @required ] if @required;
Branch: 1 branch
BranchTrueFalseTotal
if @required 5759 4676 10435
299 10435 return \%schema;
300 }
301  
302 # $class already loaded as a file (require_module needed) vs. already
303 # usable in memory (an inline-struct class the k8s DSL built synchronously
304 # when its parent's own `k8s foo => { ... }` line ran, or $class itself,
305 # already loaded by the caller of to_crd/crd_for_class). The inline-struct
306 # case has no .pm file at all -- require_module would fail "Can't locate
307 # ... in @INC" for exactly the classes _schema_for_class most needs to
308 # recurse into. can('_k8s_attr_info') is true the moment
309 # IO::K8s::Role::Resource is composed onto a package, which happens
310 # synchronously either way (_generate_inline_struct, or a real file's own
311 # `use IO::K8s::Resource;` at compile time), so it is the right question
312 # for both.
313 10767 ▶sub _ensure_class_loaded {
Subroutine _ensure_class_loaded: called CC=2 SCAR=6.9
314 10767 my ($class) = @_;
315 10767 ▶ return if $class->can('_k8s_attr_info');
Branch: 1 branch
BranchTrueFalseTotal
if $class->can("_k8s_attr_info") 10507 260 10767
316 260 require_module($class);
317 }
318  
319 36887 ▶sub _property_schema {
Subroutine _property_schema: called CC=6 SCAR=17.9
320 36887 my ($entry, $seen, $where) = @_;
321 36887 my $schema = _type_schema($entry, $seen);
322 36887 ▶ return $schema unless $entry->{options};
Branch: 1 branch
BranchTrueFalseTotal
unless $entry->{"options"} 33588 3299 36887
323  
324 # Value constraints (enum/minimum/maximum/pattern) of an [X] array or a
325 # typed map constrain each element / each value, so they belong on
326 # items / additionalProperties (k195), as IO::K8s::AutoGen reads them
327 # back. Everything else (description, default, nullable,
328 # preserve_unknown) describes the container itself and stays on it.
329 3299 my %opts = %{ $entry->{options} };
330 my $inner = ref $schema->{items} eq 'HASH' ? $schema->{items}
331 : ref $schema->{additionalProperties} eq 'HASH' ? $schema->{additionalProperties}
332 3299 ▶ : undef;
Branch: 2 branches
BranchTrueFalseTotal
ref $schema->{'items'} eq 'HASH' ? : 87 3212 3299
ref $schema->{'additionalProperties'} eq 'HASH' ? : 4 3208 3212
333 3299 ▶ if ($inner) {
Branch: 1 branch
BranchTrueFalseTotal
if ($inner) 91 3208 3299
334 91 my %value = map { $_ => delete $opts{$_} } grep { exists $opts{$_} } qw(enum minimum maximum pattern);
335 91 ▶ _apply_options($inner, \%value, $where, 0) if %value;
Branch: 1 branch
BranchTrueFalseTotal
if %value 80 11 91
336 }
337 3299 _apply_options($schema, \%opts, $where, $entry->{is_bool});
338 3289 return $schema;
339 }
340  
341 # The registry's one classifying is_* flag, turned into its schema shape --
342 # the reverse of IO::K8s::AutoGen::_schema_to_type_spec's dispatch (and
343 # IO::K8s::CRD::Emitter::_type_source's DSL-source mirror of the same
344 # flags, read alongside this while writing it).
345 #
346 # is_quantity has no format upstream ever puts on a plain `type: string`
347 # schema: AutoGen only ever reaches Quantity through a $ref to
348 # resource.Quantity, never through a format string, so there is nothing to
349 # emit here that would read back as Quantity. A Quantity field therefore
350 # round-trips through add_crd as a plain Str -- documented in the task-2
351 # report, not worked around here. is_hash_of_quantity shares the same gap
352 # for the same reason: its additionalProperties is a plain `type: string`,
353 # which AutoGen reads back as the string map HashRef[Str]. The other typed
354 # maps -- int/num/bool/time/int-or-string -- read back as themselves since
355 # k191, when AutoGen's additionalProperties dispatch stopped collapsing
356 # every one of them to the old opaque { Str => 1 }. is_array_of_quantity
357 # has the identical gap to the scalar is_quantity, one level down.
358 36887 ▶sub _type_schema {
Subroutine _type_schema: called CC=32 SCAR=34.8
359 36887 my ($entry, $seen) = @_;
360  
361 36887 ▶ return { type => 'string' } if $entry->{is_str};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_str"} 17104 19783 36887
362 19783 ▶ return { type => 'integer' } if $entry->{is_int};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_int"} 2637 17146 19783
363 17146 ▶ return { type => 'number' } if $entry->{is_num};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_num"} 6 17140 17146
364 17140 ▶ return { type => 'boolean' } if $entry->{is_bool};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_bool"} 2276 14864 17140
365 14864 ▶ return { 'x-kubernetes-int-or-string' => JSON::MaybeXS::true } if $entry->{is_int_or_string};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_int_or_string"} 468 14396 14864
366 14396 ▶ return { type => 'string' } if $entry->{is_quantity};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_quantity"} 167 14229 14396
367 14229 ▶ return { type => 'string', format => 'date-time' } if $entry->{is_time};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_time"} 399 13830 14229
368  
369 13830 ▶ return _schema_for_class($entry->{class}, $seen) if $entry->{is_object};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_object"} 7302 6528 13830
370  
371 return { type => 'array', items => _schema_for_class($entry->{class}, $seen) }
372 6528 ▶ if $entry->{is_array_of_objects};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_objects"} 2672 3856 6528
373 3856 ▶ return { type => 'array', items => { type => 'string' } } if $entry->{is_array_of_str};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_str"} 2413 1443 3856
374 1443 ▶ return { type => 'array', items => { type => 'integer' } } if $entry->{is_array_of_int};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_int"} 81 1362 1443
375 1362 ▶ return { type => 'array', items => { type => 'boolean' } } if $entry->{is_array_of_bool};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_bool"} 6 1356 1362
376 1356 ▶ return { type => 'array', items => { type => 'number' } } if $entry->{is_array_of_num};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_num"} 3 1353 1356
377 return { type => 'array', items => { 'x-kubernetes-int-or-string' => JSON::MaybeXS::true } }
378 1353 ▶ if $entry->{is_array_of_int_or_string};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_int_or_string"} 4 1349 1353
379 1349 ▶ return { type => 'array', items => { type => 'string' } } if $entry->{is_array_of_quantity};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_quantity"} 6 1343 1349
380 return { type => 'array', items => { type => 'string', format => 'date-time' } }
381 1343 ▶ if $entry->{is_array_of_time};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_time"} 4 1339 1343
382 1339 ▶ return { type => 'array', items => _opaque_object() } if $entry->{is_array_of_hash};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_hash"} 4 1335 1339
383 1335 ▶ return { type => 'array', items => { type => 'array' } } if $entry->{is_array_of_array};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_array_of_array"} 2 1333 1335
384 # Belt-and-suspenders (k96 task-2 review, Critical): every is_array_of_*
385 # flag Resource.pm can currently set is handled above. A future one that
386 # is not degrades to an untyped array items schema rather than falling
387 # through to the croak below -- a class this function cannot describe
388 # precisely should still produce a *valid*, merely permissive,
389 # openAPIV3Schema, not block to_crd outright the way the unhandled
390 # is_array_of_num/quantity/time/int_or_string case did before this fix
391 # (found via IO::K8s::Api::Resource::V1::ResourceSlice's
392 # DeviceCapacity.validValues, an [Quantity] field).
393 return { type => 'array', items => {} }
394 1333 ▶ if grep { /^is_array_of_/ && $entry->{$_} } keys %$entry;
Branch: 1 branch
BranchTrueFalseTotal
if grep {/^is_array_of_/ and $entry->{$_};} keys %$entry 0 1333 1333
Condition33%1/3
/^is_array_of_/ && $entry->{$_}
!ll&&!rl&&r
147400
MC/DC0%0/2
/^is_array_of_/ && $entry->{$_}
/^is_array_of_/ $entry->{$_}
Truth table33%1/3
A && B
A= /^is_array_of_/B= $entry->{$_}
ABresult
0X0
100
111
395  
396 return { type => 'object', additionalProperties => _schema_for_class($entry->{class}, $seen) }
397 1333 ▶ if $entry->{is_hash_of_objects};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_objects"} 40 1293 1333
398 # The string map (k191) -- HashRef[Str] and { Str => 1 } alike, a
399 # map[string]string upstream -- and the free map, Opaque / HashRef,
400 # which is what { Str => 1 } used to stand for here.
401 return { type => 'object', additionalProperties => { type => 'array', items => { type => 'string' } } }
402 1293 ▶ if $entry->{is_hash_of_str_arrays};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_str_arrays"} 17 1276 1293
403 return { type => 'object',
404 additionalProperties => { type => 'array', items => _schema_for_class($entry->{class}, $seen) } }
405 1276 ▶ if $entry->{is_hash_of_object_arrays};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_object_arrays"} 48 1228 1276
406 1228 ▶ return { type => 'object', additionalProperties => { type => 'string' } } if $entry->{is_hash_of_str};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_str"} 894 334 1228
407 334 ▶ return _opaque_object() if $entry->{is_hash_opaque};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_opaque"} 79 255 334
408 255 ▶ return { type => 'object', additionalProperties => { type => 'integer' } } if $entry->{is_hash_of_int};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_int"} 8 247 255
409 247 ▶ return { type => 'object', additionalProperties => { type => 'number' } } if $entry->{is_hash_of_num};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_num"} 0 247 247
410 247 ▶ return { type => 'object', additionalProperties => { type => 'boolean' } } if $entry->{is_hash_of_bool};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_bool"} 0 247 247
411 247 ▶ return { type => 'object', additionalProperties => { type => 'string' } } if $entry->{is_hash_of_quantity};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_quantity"} 245 2 247
412 return { type => 'object', additionalProperties => { type => 'string', format => 'date-time' } }
413 2 ▶ if $entry->{is_hash_of_time};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_time"} 1 1 2
414 return { type => 'object', additionalProperties => { 'x-kubernetes-int-or-string' => JSON::MaybeXS::true } }
415 1 ▶ if $entry->{is_hash_of_int_or_string};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"is_hash_of_int_or_string"} 1 0 1
416  
417 0 croak 'IO::K8s::CRD::_schema_for_class: registry entry with no recognizable is_* flag';
418 }
419  
420 93 ▶sub _opaque_object {
Subroutine _opaque_object: called CC=1 SCAR=0.0
421 93 return { type => 'object', 'x-kubernetes-preserve-unknown-fields' => JSON::MaybeXS::true };
422 }
423  
424 # D3 -> openAPIV3Schema: every option version 1 of D3 carries is emitted
425 # ("All of them are emitted into the CRD schema (D9)" -- the design spec's
426 # own words). 'required' is excluded here on purpose -- it is not a
427 # per-property key, it joins the ENCLOSING object's own 'required' array,
428 # handled by _schema_for_class's caller loop above.
429 3379 ▶sub _apply_options {
Subroutine _apply_options: called CC=14 SCAR=26.4
430 3379 my ($schema, $opts, $where, $is_bool) = @_;
431 3379 ▶ $schema->{enum} = [ @{ $opts->{enum} } ] if exists $opts->{enum};
Branch: 1 branch
BranchTrueFalseTotal
if exists $opts->{"enum"} 697 2682 3379
432 3379 ▶ $schema->{minimum} = $opts->{minimum} if exists $opts->{minimum};
Branch: 1 branch
BranchTrueFalseTotal
if exists $opts->{"minimum"} 274 3105 3379
433 3379 ▶ $schema->{maximum} = $opts->{maximum} if exists $opts->{maximum};
Branch: 1 branch
BranchTrueFalseTotal
if exists $opts->{"maximum"} 149 3230 3379
434 3379 ▶ if (exists $opts->{pattern}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $opts->{"pattern"}) 2107 1272 3379
435 2107 my $p = $opts->{pattern};
436 2107 ▶ $schema->{pattern} = (ref $p eq 'Regexp') ? _pattern_to_ecma262($p, $where) : $p;
Branch: 1 branch
BranchTrueFalseTotal
ref $p eq 'Regexp' ? : 2041 66 2107
437 }
438 3369 ▶ $schema->{description} = $opts->{description} if exists $opts->{description};
Branch: 1 branch
BranchTrueFalseTotal
if exists $opts->{"description"} 2 3367 3369
439 3369 ▶ if (exists $opts->{default}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $opts->{"default"}) 489 2880 3369
440 489 my $default = _copy_one_level($opts->{default});
441 489 ▶ $schema->{default} = $is_bool
Branch: 2 branches
BranchTrueFalseTotal
$is_bool ? : 31 458 489
IO::K8s::Resource::_normalize_bool($default) ? : 6 25 31
442 ? (IO::K8s::Resource::_normalize_bool($default)
443 ? JSON::MaybeXS::true
444 : JSON::MaybeXS::false)
445 : $default;
446 }
447 $schema->{nullable} = $opts->{nullable} ? JSON::MaybeXS::true : JSON::MaybeXS::false
448 3369 ▶ if exists $opts->{nullable};
Branch: 2 branches
BranchTrueFalseTotal
if exists $opts->{"nullable"} 5 3364 3369
$opts->{'nullable'} ? : 5 0 5
449 $schema->{'x-kubernetes-preserve-unknown-fields'} = $opts->{preserve_unknown} ? JSON::MaybeXS::true : JSON::MaybeXS::false
450 3369 ▶ if exists $opts->{preserve_unknown};
Branch: 2 branches
BranchTrueFalseTotal
if exists $opts->{"preserve_unknown"} 26 3343 3369
$opts->{'preserve_unknown'} ? : 26 0 26
451 3369 return;
452 }
453  
454 #### qr// -> ECMA262, for openAPIV3Schema.pattern (k110)
455 #
456 # A CRD's openAPIV3Schema.pattern is an ECMA262 regex -- that is what JSON
457 # Schema specifies and what the apiserver validates against. A Perl qr// is
458 # not one, and the two flavors overlap enough that emitting the qr// text
459 # verbatim fails SILENTLY: the apiserver either rejects the whole CRD, or
460 # accepts a pattern that matches something other than what the Perl class
461 # itself validates with (relevant to Kubernetes::REST's ensure_crd).
462 #
463 # The rule is translate-on-emit, bounded:
464 #
465 # * Only a qr// is translated. A pattern given as a plain string is
466 # passed through untouched by _apply_options above -- that string is
467 # already meant to be the wire pattern (it is also exactly what
468 # IO::K8s::AutoGen hands back out of a real CRD's own schema), and
469 # re-parsing someone else's ECMA262 text as if it were Perl would be
470 # the opposite of bounded.
471 # * A qr// is translated where the translation is lossless, and croaks
472 # everywhere else. Nothing is emitted on a guess.
473 #
474 # What is translated:
475 #
476 # \A -> ^ and \z -> $. Both hold only because /m is rejected below:
477 # with no /m, ECMA262 '^' and '$' anchor the whole input, which is
478 # precisely what Perl's \A and \z mean. \Z is NOT '$' -- Perl's \Z also
479 # matches before a final newline -- so it croaks instead of being quietly
480 # equated with it.
481 #
482 # Everything ECMA262 spells identically -- literals, character classes,
483 # (?:...), lookaround, backreferences, lazy quantifiers, \d \w \s \b,
484 # {n,m} -- is copied verbatim.
485 #
486 # The scan is textual and conservative rather than a real regex parser, but
487 # it tracks the escape level and character-class nesting, so an escaped
488 # construct (a literal \\K, or a ']' inside a class) is not mistaken for
489 # the real thing, and it errs towards croaking.
490 #
491 # What it deliberately does NOT reject are the constructs Perl and the
492 # apiserver's own engine agree on even though strict ECMA262 does not:
493 # \p{...}/\P{...}/\pC and \x{...}. Rejecting them would break checked-in
494 # classes to satisfy a rule the validator on the other end does not
495 # implement -- Cilium's LogConfig.value is qr/^\PC*$/ straight out of the
496 # upstream CRD, so a shipped class really does carry one.
497 #
498 # That upstream \PC is the whole of the case now (k114). Until then this
499 # also rested on IO::K8s::CRD::Emitter rendering a non-ASCII pattern as
500 # \x{HEX}, which made a shipped \x{...} something this distribution
501 # produced by itself -- and that is exactly what k114 stopped doing: such a
502 # pattern is emitted as a plain string carrying the codepoint, so the
503 # escape no longer reaches a registry from that direction. A \x{...} here
504 # can now only come from a hand-written class, and it is still let through
505 # for the same reason \PC is: Go/RE2 takes it.
506  
507 # Regex flags that change what the pattern MEANS and have no carrier in a
508 # bare pattern string. The charset flags (a/d/l/u) and /p are absent on
509 # purpose: they do not change the meaning of the ASCII-oriented text a CRD
510 # pattern carries, and a plain qr// picks 'u' up on its own from a feature
511 # bundle (qr/^\PC*$/ in Cilium's LogConfig already reports flags 'u'), so
512 # croaking on those would reject patterns that were never given a flag.
513 # /n is here -- it silently turns every (...) into a non-capturing group.
514 31 my %_PATTERN_BAD_FLAG = (
515 i => 'case-insensitive matching (/i)',
516 m => 'multiline anchors (/m)',
517 s => 'dot-matches-newline (/s)',
518 x => 'extended, whitespace-insensitive syntax (/x)',
519 n => 'non-capturing groups (/n)',
520 );
521  
522 # Backslash escapes that are Perl-only or -- worse -- mean something
523 # DIFFERENT in ECMA262. \v is the trap: vertical whitespace in Perl, a
524 # plain vertical tab (\x0B) there. Keyed by the character after the
525 # backslash; the scan only consults this after establishing that the
526 # backslash is not itself escaped.
527 31 my %_PATTERN_BAD_ESCAPE = (
528 'Z' => '\Z (Perl end-of-string-or-before-final-newline; ECMA262 $ is not the same)',
529 'K' => '\K (keep, Perl-only)',
530 'G' => '\G (pos() anchor, Perl-only)',
531 'h' => '\h (horizontal whitespace, Perl-only)',
532 'H' => '\H (non-horizontal-whitespace, Perl-only)',
533 'v' => '\v (vertical whitespace in Perl, a vertical TAB in ECMA262)',
534 'V' => '\V (non-vertical-whitespace, Perl-only)',
535 'R' => '\R (linebreak, Perl-only)',
536 'N' => '\N (non-newline, or \N{NAME}, Perl-only)',
537 'X' => '\X (extended grapheme cluster, Perl-only)',
538 'C' => '\C (single byte, Perl-only)',
539 'o' => '\o{...} (octal escape, Perl-only)',
540 'g' => '\g backreference (Perl-only; ECMA262 has \1 and \k<name>)',
541 );
542  
543 10 ▶sub _pattern_croak {
Subroutine _pattern_croak: called CC=3 SCAR=13.1
544 10 my ($where, $text, $what) = @_;
545 10 ▶ croak 'IO::K8s::CRD: pattern for '
Branch: 1 branch
BranchTrueFalseTotal
defined $where && length $where ? : 10 0 10
Condition33%1/3
defined $where and length $where
!ll&&!rl&&r
0010
MC/DC0%0/2
defined $where and length $where
defined $where length $where
Truth table33%1/3
A and B
A= defined $whereB= length $where
ABresult
0X0
100
111
546 . (defined $where && length $where ? $where : 'an unnamed field')
547 . " cannot be emitted as ECMA262: it uses $what."
548 . ' openAPIV3Schema.pattern is an ECMA262 regex -- rewrite the field'
549 . ' pattern, or give it as a plain string to emit it verbatim.'
550 . ' Pattern: qr/' . $text . '/';
551 }
552  
553 3180 ▶sub _pattern_to_ecma262 {
Subroutine _pattern_to_ecma262: called CC=25 SCAR=32.3
554 3180 my ($re, $where) = @_;
555  
556 # LIST context gives ($raw_text, $flags): the text a qr// was built
557 # from, with no '(?^u:...)' wrapper around it (which is what plain
558 # stringification would produce), plus the flags as their own string.
559 3180 my ($text, $flags) = re::regexp_pattern($re);
560 3180 ▶ $flags = '' unless defined $flags;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $flags 0 3180 3180
561  
562 3180 my @bad_flags = grep { exists $_PATTERN_BAD_FLAG{$_} } split //, $flags;
563 3180 ▶ _pattern_croak($where, $text, join(' and ', map { $_PATTERN_BAD_FLAG{$_} } @bad_flags))
Branch: 1 branch
BranchTrueFalseTotal
if @bad_flags 5 3175 3180
564 if @bad_flags;
565  
566 3175 my $out = '';
567 3175 my $len = length $text;
568 3175 my $i = 0;
569 3175 my $in_class = 0;
570  
571 3175 ▶ while ($i < $len) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < $len) 208424 3170 211594
572 208424 my $rest = substr($text, $i);
573  
574 # Escapes first, so that a backslashed construct is never read as
575 # the construct itself.
576 208424 ▶ if ($rest =~ /\A\\(.)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($rest =~ /\A\\(.)/s) 4236 204188 208424
577 4236 my $esc = $1;
578 _pattern_croak($where, $text, $_PATTERN_BAD_ESCAPE{$esc})
579 4236 ▶ if exists $_PATTERN_BAD_ESCAPE{$esc};
Branch: 1 branch
BranchTrueFalseTotal
if exists $_PATTERN_BAD_ESCAPE{$esc} 2 4234 4236
580 4234 ▶ _pattern_croak($where, $text,
Branch: 1 branch
BranchTrueFalseTotal
if $esc eq "k" and not $rest =~ /\A\\k</ 0 4234 4234
Condition33%1/3
$esc eq "k" and not $rest =~ /\A\\k</
!ll&&!rl&&r
423400
MC/DC0%0/2
$esc eq "k" and not $rest =~ /\A\\k</
$esc eq "k" not $rest =~ /\A\\k</
Truth table33%1/3
A and not(B)
A= $esc eq "k"B= not $rest =~ /\A\\k</
ABresult
0X0
100
111
581 q{\k{...} or \k'...' (Perl-only; ECMA262 spells it \k<name>)})
582 if $esc eq 'k' && $rest !~ /\A\\k</;
583  
584 4234 ▶ if ($esc eq 'A' || $esc eq 'z') {
Branch: 1 branch
BranchTrueFalseTotal
if ($esc eq "A" or $esc eq "z") 13 4221 4234
Condition100%3/3
$esc eq "A" or $esc eq "z"
l!l&&r!l&&!r
944221
MC/DC100%2/2
$esc eq "A" or $esc eq "z"
$esc eq "A" $esc eq "z"
Truth table100%3/3
A or B
A= $esc eq "A"B= $esc eq "z"
ABresult
1X1
011
000
585 # Inside a character class these are not anchors at all
586 # (Perl itself warns), so there is nothing to translate
587 # them into -- croak rather than emit either reading.
588 13 ▶ _pattern_croak($where, $text, "\\$esc inside a character class")
Branch: 1 branch
BranchTrueFalseTotal
if $in_class 0 13 13
589 if $in_class;
590 13 ▶ $out .= ($esc eq 'A' ? '^' : '$');
Branch: 1 branch
BranchTrueFalseTotal
$esc eq 'A' ? : 9 4 13
591 13 $i += 2;
592 13 next;
593 }
594  
595 # Copied whole, so the braces they carry are never read as a
596 # {n,m} quantifier by the possessive check further down
597 # (\x{31}+ is one escape plus a '+', not '{31}' made
598 # possessive).
599 4221 ▶ if ($rest =~ /\A(\\[pPx]\{[^}]*\})/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($rest =~ /\A(\\[pPx]\{[^}]*\})/) 0 4221 4221
600 0 $out .= $1;
601 0 $i += length $1;
602 0 next;
603 }
604  
605 4221 $out .= substr($text, $i, 2);
606 4221 $i += 2;
607 4221 next;
608 }
609  
610 204188 my $c = substr($text, $i, 1);
611  
612 204188 ▶ if ($in_class) {
Branch: 1 branch
BranchTrueFalseTotal
if ($in_class) 105001 99187 204188
613 105001 ▶ _pattern_croak($where, $text,
Branch: 1 branch
BranchTrueFalseTotal
if $c eq "[" and $rest =~ /\A\[:\^?[a-z]+:\]/ 1 105000 105001
Condition66%2/3
$c eq "[" and $rest =~ /\A\[:\^?[a-z]+:\]/
!ll&&!rl&&r
10500001
MC/DC50%1/2
$c eq "[" and $rest =~ /\A\[:\^?[a-z]+:\]/
$c eq "[" $rest =~ /\A\[:\^?[a-z]+:\]/
Truth table66%2/3
A and B
A= $c eq "["B= $rest =~ /\A\[:\^?[a-z]+:\]/
ABresult
0X0
100
111
614 'a POSIX character class ([[:alpha:]] and friends, Perl-only)')
615 if $c eq '[' && $rest =~ /\A\[:\^?[a-z]+:\]/;
616 105000 ▶ $in_class = 0 if $c eq ']';
Branch: 1 branch
BranchTrueFalseTotal
if $c eq "]" 16363 88637 105000
617 105000 $out .= $c;
618 105000 $i++;
619 105000 next;
620 }
621  
622 99187 ▶ if ($c eq '[') {
Branch: 1 branch
BranchTrueFalseTotal
if ($c eq "[") 16364 82823 99187
623 # A ']' straight after '[' or '[^' is a literal, not the close,
624 # so it is consumed with the opener and $in_class can then
625 # close on the very next ']' it sees.
626 16364 my ($open) = $rest =~ /\A(\[\^?\]?)/;
627 16364 $out .= $open;
628 16364 $i += length $open;
629 16364 $in_class = 1;
630 16364 next;
631 }
632  
633 82823 ▶ if ($c eq '(') {
Branch: 1 branch
BranchTrueFalseTotal
if ($c eq "(") 12735 70088 82823
634 12735 ▶ if (substr($text, $i, 2) eq '(?') {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($text, $i, 2) eq "(?") 2 12733 12735
635 # Whitelist, not a blacklist: everything ECMA262 has is
636 # listed here, so atomic groups (?>...), code blocks
637 # (?{...})/(??{...}), comments (?#...), conditionals
638 # (?(...)...), branch reset (?|...), recursion
639 # (?R)/(?1)/(?&name), the (?'name'...)/(?P<name>...)
640 # spellings, inline modifiers (?i)/(?-i:...) and a nested
641 # qr//'s own (?^u:...) wrapper all land in the croak
642 # without needing a rule each.
643 2 ▶ if ($rest =~ /\A(\(\?(?::|=|!|<[=!]|<[A-Za-z_]\w*>))/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($rest =~ /\A(\(\?(?::|=|!|<[=!]|<[A-Za-z_]\w*>))/) 1 1 2
644 1 $out .= $1;
645 1 $i += length $1;
646 1 next;
647 }
648 1 my ($shown) = $rest =~ /\A(\(\?.{0,3})/s;
649 1 _pattern_croak($where, $text, "the group construct '$shown'"
650 . ' (ECMA262 has only (?:...), lookaround and (?<name>...))');
651 }
652 12733 $out .= '(';
653 12733 $i++;
654 12733 next;
655 }
656  
657 70088 ▶ if ($rest =~ /\A(\*|\+|\?|\{\d+(?:,\d*)?\})/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($rest =~ /\A(\*|\+|\?|\{\d+(?:,\d*)?\})/) 15841 54247 70088
658 15841 my $quant = $1;
659 15841 $out .= $quant;
660 15841 $i += length $quant;
661 15841 ▶ my $mod = $i < $len ? substr($text, $i, 1) : '';
Branch: 1 branch
BranchTrueFalseTotal
$i < $len ? : 15830 11 15841
662 15841 ▶ _pattern_croak($where, $text, "the possessive quantifier '$quant+' (Perl-only)")
Branch: 1 branch
BranchTrueFalseTotal
if $mod eq "+" 1 15840 15841
663 if $mod eq '+';
664 15840 ▶ if ($mod eq '?') { # lazy: valid ECMA262, but consume it so it
Branch: 1 branch
BranchTrueFalseTotal
if ($mod eq "?") 1 15839 15840
665 1 $out .= '?'; # is not re-read as a quantifier of its own
666 1 $i++;
667 }
668 15840 next;
669 }
670  
671 54247 $out .= $c;
672 54247 $i++;
673 }
674  
675 3170 return $out;
676 }
677  
678 # One level of copying for a 'default' option that might be an array/hash
679 # ref -- the registry never copies 'default' itself (only 'enum'; see
680 # IO::K8s::Resource::_k8s), so a plain assignment here would alias the
681 # class's own stored default the same way k54 warns against elsewhere.
682 # Duplicated from IO::K8s::Role::Resource::_copy_one_level rather than
683 # called cross-package, for the same reason that one gives for not calling
684 # IO::K8s.pm's version: this file must not force-load IO::K8s at compile
685 # time (see crd_for_class's own lazy 'require IO::K8s' above).
686 489 ▶sub _copy_one_level {
Subroutine _copy_one_level: called CC=3 SCAR=11.0
687 489 my ($value) = @_;
688 489 ▶ return [ @$value ] if ref $value eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "ARRAY" 11 478 489
689 478 ▶ return { %$value } if ref $value eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "HASH" 18 460 478
690 460 return $value;
691 }
692  
693 31 1;
694  
695 __END__
« lib/IO/K8s/Role/Routable.pm ↑ Summary blib/lib/IO/K8s/APIObject.pm »