blib/lib/IO/K8s/Role/Resource.pm

filter: Statementstmt 90.4% 266 / 294 Branchbran 73.3% 157 / 214 Conditioncond 58.4% 69 / 118 MC/DCmcdc 28.7% 21 / 73 Subroutinesub 100% 33 / 33 Podpod 87.5% 7 / 8 totaltotal 74.7% 553 / 740 CC 167 SCAR 41.8
CC
167
Cov
79%
_describe_local_type
154.2
TO_JSON
101.6
_describe_schema_type
57.1
CRAP 65.1
« maint/crd-drift-check.pl ↑ Summary blib/lib/IO/K8s/AutoGen.pm »
1 package IO::K8s::Role::Resource;
2 # ABSTRACT: Role providing Kubernetes resource instance behavior
3 160 our $VERSION = '1.112';
4 160 ▶use v5.10;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 160 ▶use Moo ();
Subroutine BEGIN: called CC=1 SCAR=0.0
6 160 ▶use mro ();
Subroutine BEGIN: called CC=1 SCAR=0.0
7 160 ▶use Types::Standard qw(HashRef);
Subroutine BEGIN: called CC=1 SCAR=0.0
8 160 ▶use JSON::MaybeXS ();
Subroutine BEGIN: called CC=1 SCAR=0.0
9 160 ▶use Scalar::Util qw(blessed);
Subroutine BEGIN: called CC=1 SCAR=0.0
10 # Imports above `use Moo::Role` on purpose: Role::Tiny treats subs already in
11 # the package as not-methods, so their names stay off every consumer. A `use`
12 # below that line composes its exports onto all shipped classes (k118).
13 160 ▶use Moo::Role;
Subroutine BEGIN: called CC=1 SCAR=0.0
14 160 our @CARP_NOT = ('IO::K8s'); # FROM_HASH/from_json errors name their caller (k175)
15  
16 160 has _json_encoder => (
17 is => 'ro',
18 lazy => 1,
19 builder => '_build__json_encoder',
20 );
21  
22 8030 ▶sub _build__json_encoder {
Subroutine _build__json_encoder: called CC=1 SCAR=0.0
23 8030 return JSON::MaybeXS->new(utf8 => 1, canonical => 1);
24 }
25  
26 # Constructor arguments no attribute claims (D1). Kept so a document from a
27 # newer upstream than the class round-trips instead of losing fields; TO_JSON
28 # emits them again, declared attributes winning on a name clash. Filled by
29 # the BUILD below; SpecBuilder writes undeclared keys here too.
30 # Not a k8s-registered attribute, so TO_JSON's attribute walk never sees the
31 # bag as a field of its own.
32 has _unknown_fields => (
33 is => 'rw',
34 isa => HashRef,
35 init_arg => '_unknown_fields',
36 86545 ▶ default => sub { {} },
Subroutine __ANON__: called CC=1 SCAR=0.0
37 160 );
38  
39 # The registry lookup is the hot path (every inflate / TO_JSON), so the
40 # merged views are cached per class. IO::K8s::Resource::_k8s() invalidates
41 # the affected entries whenever it registers a new attribute.
42 160 my %_attr_info_cache;
43 my %_attributes_cache;
44 160 my %_known_init_args_cache;
45  
46 # Every constructor key a class accepts: the JSON key of each k8s-registered
47 # attribute (json_key when the Perl name was sanitized), the init_arg of every
48 # Moo attribute declared with a plain `has` anywhere in the class's ancestry
49 # (metadata from Role::APIObject, json, _unknown_fields itself), and
50 # apiVersion/kind on a top-level object, which Role::APIObject supplies as
51 # methods rather than attributes. The Moo side is read from each ancestor's
52 # own constructor maker -- the same view MooX::StrictConstructor uses; Moo
53 # has no public accessor for it -- because all_attribute_specs only ever
54 # returns a class's *own* specs, never its parents'. A subclass created
55 # without `use Moo` (e.g. `use parent -norequire, 'IO::K8s::Api::...::Pod'`)
56 # has no constructor maker of its own at all, so the walk covers the whole
57 # linear ISA via mro::get_linear_isa rather than looking at $class alone.
58 86405 ▶sub _known_init_args {
Subroutine _known_init_args: called CC=2 SCAR=7.1
59 86405 my ($class) = @_;
60 86405 ▶ return $_known_init_args_cache{$class} //= _collect_known_init_args($class);
Condition66%2/3
$_known_init_args_cache{$class} //= _collect_known_init_args($class)
l!l&&r!l&&!r
8227641290
MC/DC0%0/2
$_known_init_args_cache{$class} //= _collect_known_init_args($class)
$_known_init_args_cache{$class} _collect_known_init_args($class)
Truth table66%2/3
A //= B
A= $_known_init_args_cache{$class}B= _collect_known_init_args($class)
ABresult
1X1
011
000
61 }
62  
63 4129 ▶sub _collect_known_init_args {
Subroutine _collect_known_init_args: called CC=7 SCAR=19.5
64 4129 my ($class) = @_;
65 4129 my %known;
66 4129 my $info = _k8s_attr_info($class);
67 4129 for my $attr (keys %$info) {
68 20639 ▶ $known{ $info->{$attr}{json_key} // $attr } = 1;
Condition66%2/3
$info->{$attr}{"json_key"} // $attr
l!l&&r!l&&!r
417202220
MC/DC0%0/2
$info->{$attr}{"json_key"} // $attr
$info->{$attr}{"json_key"} $attr
Truth table66%2/3
A // B
A= $info->{$attr}{"json_key"}B= $attr
ABresult
1X1
011
000
69 }
70 4129 my $specs = _effective_attribute_specs($class);
71 4129 for my $name (keys %$specs) {
72 29017 my $spec = $specs->{$name};
73 29017 ▶ my $init = exists $spec->{init_arg} ? $spec->{init_arg} : $name;
Branch: 1 branch
BranchTrueFalseTotal
exists $spec->{'init_arg'} ? : 29016 1 29017
74 29017 ▶ $known{$init} = 1 if defined $init;
Branch: 1 branch
BranchTrueFalseTotal
if defined $init 29017 0 29017
75 }
76 4129 ▶ if ($class->can('_is_resource')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($class->can("_is_resource")) 724 3405 4129
77 724 $known{apiVersion} = 1;
78 724 $known{kind} = 1;
79 }
80 4129 return \%known;
81 }
82  
83 # The Moo attribute specs that are in effect for $class: attribute name ->
84 # spec, nearest first over mro::get_linear_isa, so a subclass's own `has`
85 # for a name hides every ancestor's spec of that name. Read from each
86 # ancestor's constructor maker for the reasons given above
87 # _known_init_args. Private, uncached and free of side effects on the
88 # registry: _collect_known_init_args uses it for the constructor keys,
89 # IO::K8s::Resource's declaration preflight (k144) to tell a real Moo
90 # attribute from a same-named method -- the registry alone never proves an
91 # attribute exists.
92 5970 ▶sub _effective_attribute_specs {
Subroutine _effective_attribute_specs: called CC=5 SCAR=16.1
93 5970 my ($class) = @_;
94 5970 my %specs;
95 5970 for my $ancestor (@{ mro::get_linear_isa($class) }) {
96 11959 ▶ my $maker = Moo->_constructor_maker_for($ancestor) or next;
Branch: 1 branch
BranchTrueFalseTotal
my $maker = "Moo"->_constructor_maker_for($ancestor) or next 5985 5974 11959
97 5985 my $own = $maker->all_attribute_specs;
98 5985 for my $name (keys %$own) {
99 35588 ▶ $specs{$name} = $own->{$name} unless exists $specs{$name};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $specs{$name} 35515 73 35588
100 }
101 }
102 5970 return \%specs;
103 }
104  
105 # One level of copying for a plain container -- the same depth TO_JSON and
106 # IO::K8s::_inflate_struct use (k54), duplicated here because IO::K8s.pm is
107 # loaded after this role and must not be required from it.
108 5029 ▶sub _copy_one_level {
Subroutine _copy_one_level: called CC=3 SCAR=11.0
109 5029 my ($value) = @_;
110 5029 ▶ return [ @$value ] if ref $value eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "ARRAY" 74 4955 5029
111 4955 ▶ return { %$value } if ref $value eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "HASH" 143 4812 4955
112 4812 return $value;
113 }
114  
115 # BUILD, not `around BUILDARGS` (k102). The walk, its order and everything
116 # it decides are unchanged; only the plumbing Moo has to generate around it
117 # differs, and the two are not priced alike. Measured on a quiet box, a
118 # three-attribute Moo class: 4.85 us/construction plain, 6.51 us with an
119 # `around BUILDARGS` whose body is empty, 5.31 us with an empty `sub BUILD`
120 # -- 1.66 us of pure plumbing against 0.46 us, on every one of the ~850
121 # classes and every nested object of every inflated document. Against the
122 # t/25 Dashboard Deployment (22 objects) that is -2.6% [IQR -4.5..+4.1],
123 # i.e. inside the run-to-run spread; on a small direct ->new it is
124 # -9.8%/-8.5% with a tight interval, and that is the honest claim.
125 #
126 # Two things the move does NOT change, both checked before it was made:
127 # * an unknown key is no longer deleted from the argument hash, because
128 # BUILD runs after the constructor -- Moo ignores a constructor key no
129 # attribute claims, so it lands nowhere either way;
130 # * the field STRICT names first is still the innermost one, since
131 # _inflate_struct builds children before their parent and each child's
132 # BUILD therefore runs first. (Classifying the keys up in
133 # _inflate_struct instead would invert that, which is why it is a
134 # separate decision and not part of this change.)
135 #
136 # The bag is written through its own writer rather than the object slot: the
137 # common case writes nothing at all, so the accessor's cost is paid only by
138 # a document that actually carries an undeclared field, and the role stays
139 # clear of assumptions about Moo's storage layout.
140 86405 ▶sub BUILD {
Subroutine BUILD: called CC=7 SCAR=19.5
Pod undocumented
141 86405 my ($self, $args) = @_;
142 86405 my $class = ref $self;
143 86405 my $known = _known_init_args($class);
144 86405 my %unknown;
145 # sort: with several unknown keys, STRICT's die names a deterministic
146 # one instead of whichever `keys` happened to hash first.
147 86405 for my $key (sort keys %$args) {
148 179646 ▶ next if $known->{$key};
Branch: 1 branch
BranchTrueFalseTotal
if $known->{$key} 179591 55 179646
149 55 ▶ die "Unknown field '$key' for $class\n" if $IO::K8s::Resource::STRICT;
Branch: 1 branch
BranchTrueFalseTotal
if $IO::K8s::Resource::STRICT 17 38 55
150 38 my $value = $args->{$key};
151 38 ▶ next unless defined $value;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $value 1 37 38
152 37 $unknown{$key} = _copy_one_level($value);
153 }
154 86388 ▶ if (%unknown) {
Branch: 2 branches
BranchTrueFalseTotal
if (%unknown) { } 33 86355 86388
elsif (exists $args->{'_unknown_fields'}) { } 2 86353 86355
155 # A caller-supplied _unknown_fields hashref must not be aliased --
156 # the merge below builds a new hash, which is the same one-level
157 # copy every other value crossing this boundary gets.
158 33 my $bag = $self->_unknown_fields;
159 33 $self->_unknown_fields({ %$bag, %unknown });
160 }
161 elsif (exists $args->{_unknown_fields}) {
162 # Nothing collected here, but the caller handed one in: copy it one
163 # level so later edits to their hashref do not reach the object.
164 2 $self->_unknown_fields(_copy_one_level($args->{_unknown_fields}));
165 }
166 86388 return;
167 }
168  
169 # Get merged attribute info from the global registry in IO::K8s::Resource,
170 # walking @ISA so a consumer subclass registered via class_namespaces sees
171 # its parents' attributes. Nearest wins: a class's own entry for a name
172 # beats any inherited one; @ISA order (depth-first, left to right) is
173 # deterministic, so diamond shapes resolve to the first declarer.
174 140035 ▶sub _k8s_attr_info {
Subroutine _k8s_attr_info: called CC=3 SCAR=11.0
175 140035 my ($class) = @_;
176 140035 ▶ $class = ref($class) if ref($class);
Branch: 1 branch
BranchTrueFalseTotal
if ref $class 49010 91025 140035
177 140035 ▶ return $_attr_info_cache{$class} //= _merged_attr_info($class);
Condition66%2/3
$_attr_info_cache{$class} //= _merged_attr_info($class)
l!l&&r!l&&!r
13454954860
MC/DC0%0/2
$_attr_info_cache{$class} //= _merged_attr_info($class)
$_attr_info_cache{$class} _merged_attr_info($class)
Truth table66%2/3
A //= B
A= $_attr_info_cache{$class}B= _merged_attr_info($class)
ABresult
1X1
011
000
178 }
179  
180 10987 ▶sub _merged_attr_info {
Subroutine _merged_attr_info: called CC=5 SCAR=16.1
181 10987 my ($class) = @_;
182 10987 ▶ my %info = %{ $IO::K8s::Resource::_attr_registry{$class} // {} };
Condition100%2/2
$IO::K8s::Resource::_attr_registry{$class} // {}
l!l
53775610
MC/DC100%1/1
$IO::K8s::Resource::_attr_registry{$class} // {}
$IO::K8s::Resource::_attr_registry{$class}
Truth table100%2/2
A
A= $IO::K8s::Resource::_attr_registry{$class}
Aresult
11
00
183 160 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
184 10987 for my $parent (@{"${class}::ISA"}) {
185 5501 my $parent_info = _merged_attr_info($parent);
186 5501 for my $attr (keys %$parent_info) {
187 47 ▶ $info{$attr} //= $parent_info->{$attr};
Condition66%2/3
$info{$attr} //= $parent_info->{$attr}
l!l&&r!l&&!r
7400
MC/DC0%0/2
$info{$attr} //= $parent_info->{$attr}
$info{$attr} $parent_info->{$attr}
Truth table66%2/3
A //= B
A= $info{$attr}B= $parent_info->{$attr}
ABresult
1X1
011
000
188 }
189 }
190 10987 return \%info;
191 }
192  
193 # Get attribute list (stored as per-class package variables), merged with
194 # ancestors as a UNION: a class's own declarations first, then each parent's
195 # in @ISA order, deduplicated so an overridden name appears once.
196 47856 ▶sub _k8s_attributes {
Subroutine _k8s_attributes: called CC=3 SCAR=11.3
197 47856 my ($self) = @_;
198 47856 ▶ my $class = ref($self) || $self;
Condition66%2/3
ref $self || $self
l!l&&r!l&&!r
477391170
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table66%2/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
199 47856 ▶ return $_attributes_cache{$class} //= _collect_attributes($class);
Condition66%2/3
$_attributes_cache{$class} //= _collect_attributes($class)
l!l&&r!l&&!r
4407037860
MC/DC0%0/2
$_attributes_cache{$class} //= _collect_attributes($class)
$_attributes_cache{$class} _collect_attributes($class)
Truth table66%2/3
A //= B
A= $_attributes_cache{$class}B= _collect_attributes($class)
ABresult
1X1
011
000
200 }
201  
202 3786 ▶sub _collect_attributes {
Subroutine _collect_attributes: called CC=1 SCAR=0.0
203 3786 my ($class) = @_;
204 3786 my (@attrs, %seen);
205 3786 _append_attributes($class, \@attrs, \%seen);
206 3786 return \@attrs;
207 }
208  
209 7583 ▶sub _append_attributes {
Subroutine _append_attributes: called CC=4 SCAR=13.9
210 7583 my ($class, $attrs, $seen) = @_;
211 160 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
212 7583 for my $attr (@{"${class}::_k8s_attributes"}) {
213 18627 ▶ next if $seen->{$attr}++;
Branch: 1 branch
BranchTrueFalseTotal
if $seen->{$attr}++ 6 18621 18627
214 18621 push @$attrs, $attr;
215 }
216 7583 for my $parent (@{"${class}::ISA"}) {
217 3797 _append_attributes($parent, $attrs, $seen);
218 }
219 }
220  
221 # Invalidate the merged-view caches for a class and every cached descendant
222 # after IO::K8s::Resource::_k8s() registers a new attribute. The direct hit
223 # covers the registering class; the descendant sweep covers a class whose
224 # merged view was already computed before its parent gained the attribute
225 # (the same subclass drift this module exists to fix).
226 30471 ▶sub _invalidate_k8s_attr_cache {
Subroutine _invalidate_k8s_attr_cache: called CC=4 SCAR=15.0
227 30471 my ($class) = @_;
228 30471 delete $_attr_info_cache{$class};
229 30471 delete $_attributes_cache{$class};
230 30471 delete $_known_init_args_cache{$class};
231 30471 my %sweep;
232 30471 @sweep{keys %_attr_info_cache, keys %_attributes_cache, keys %_known_init_args_cache} = ();
233 30471 for my $cached_class (keys %sweep) {
234 1486909 ▶ next if $cached_class eq $class;
Branch: 1 branch
BranchTrueFalseTotal
if $cached_class eq $class 0 1486909 1486909
235 1486909 ▶ next unless $cached_class->isa($class);
Branch: 1 branch
BranchTrueFalseTotal
unless $cached_class->isa($class) 1486909 0 1486909
236 0 delete $_attr_info_cache{$cached_class};
237 0 delete $_attributes_cache{$cached_class};
238 0 delete $_known_init_args_cache{$cached_class};
239 }
240 }
241  
242  
243 47739 ▶sub TO_JSON {
Subroutine TO_JSON: called CC=82 SCAR=46.2
Pod documented
244 47739 my $self = shift;
245 47739 my %data;
246 47739 my $attrs = $self->_k8s_attributes;
247 47739 my $info = _k8s_attr_info($self);
248  
249 # Add apiVersion, kind, and metadata for APIObjects (those with the role)
250 47739 ▶ if ($self->can('_is_resource') && $self->_is_resource) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->can("_is_resource") and $self->_is_resource) 2486 45253 47739
Condition66%2/3
$self->can("_is_resource") and $self->_is_resource
!ll&&!rl&&r
4525302486
MC/DC50%1/2
$self->can("_is_resource") and $self->_is_resource
$self->can("_is_resource") $self->_is_resource
Truth table66%2/3
A and B
A= $self->can("_is_resource")B= $self->_is_resource
ABresult
0X0
100
111
251 2486 ▶ $data{apiVersion} = $self->api_version if $self->api_version;
Branch: 1 branch
BranchTrueFalseTotal
if $self->api_version 2486 0 2486
252 2486 ▶ $data{kind} = $self->kind if $self->kind;
Branch: 1 branch
BranchTrueFalseTotal
if $self->kind 2486 0 2486
253 # metadata comes from the Role, not from k8s DSL
254 2486 ▶ if ($self->can('metadata') && $self->metadata) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->can("metadata") and $self->metadata) 1649 837 2486
Condition66%2/3
$self->can("metadata") and $self->metadata
!ll&&!rl&&r
08371649
MC/DC50%1/2
$self->can("metadata") and $self->metadata
$self->can("metadata") $self->metadata
Truth table66%2/3
A and B
A= $self->can("metadata")B= $self->metadata
ABresult
0X0
100
111
255 1649 $data{metadata} = $self->metadata->TO_JSON;
256 }
257 }
258  
259 47739 for my $attr (@$attrs) {
260 446153 my $value = $self->$attr;
261 446153 ▶ unless (defined $value) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $value) 286035 160118 446153
262 # A nullable field present with undef is an explicit JSON null
263 # (k158); has_<accessor> tells it from an absent one. Every
264 # other undefined field is omitted, as it always was.
265 286035 ▶ my $opts = $info->{$attr} && $info->{$attr}{options};
Condition66%2/3
$info->{$attr} && $info->{$attr}{'options'}
!ll&&!rl&&r
02821603875
MC/DC50%1/2
$info->{$attr} && $info->{$attr}{'options'}
$info->{$attr} $info->{$attr}{'options'}
Truth table66%2/3
A && B
A= $info->{$attr}B= $info->{$attr}{'options'}
ABresult
0X0
100
111
266 286035 ▶ next unless $opts && $opts->{nullable};
Branch: 1 branch
BranchTrueFalseTotal
unless $opts and $opts->{"nullable"} 285897 138 286035
Condition100%3/3
$opts and $opts->{"nullable"}
!ll&&!rl&&r
2821603737138
MC/DC100%2/2
$opts and $opts->{"nullable"}
$opts $opts->{"nullable"}
Truth table100%3/3
A and B
A= $optsB= $opts->{"nullable"}
ABresult
0X0
100
111
267 138 my ($has) = IO::K8s::Resource::_nullable_methods($attr);
268 138 ▶ $data{ $info->{$attr}{json_key} // $attr } = undef if $self->$has;
Branch: 1 branch
BranchTrueFalseTotal
if $self->$has 74 64 138
Condition33%1/3
$info->{$attr}{"json_key"} // $attr
l!l&&r!l&&!r
0740
MC/DC0%0/2
$info->{$attr}{"json_key"} // $attr
$info->{$attr}{"json_key"} $attr
Truth table33%1/3
A // B
A= $info->{$attr}{"json_key"}B= $attr
ABresult
1X1
011
000
269 138 next;
270 }
271  
272 160118 ▶ my $attr_info = $info->{$attr} // {};
Condition50%1/2
$info->{$attr} // {}
l!l
1601180
MC/DC0%0/1
$info->{$attr} // {}
$info->{$attr}
Truth table50%1/2
A
A= $info->{$attr}
Aresult
11
00
273 # Use json_key for output when attr name differs from JSON field name
274 160118 ▶ my $key = $attr_info->{json_key} // $attr;
Condition66%2/3
$attr_info->{"json_key"} // $attr
l!l&&r!l&&!r
25011576170
MC/DC0%0/2
$attr_info->{"json_key"} // $attr
$attr_info->{"json_key"} $attr
Truth table66%2/3
A // B
A= $attr_info->{"json_key"}B= $attr
ABresult
1X1
011
000
275  
276 160118 ▶ if ($attr_info->{is_bool}) {
Branch: 25 branches
BranchTrueFalseTotal
if ($attr_info->{'is_bool'}) { } 11716 148402 160118
elsif ($attr_info->{'is_int'}) { } 12090 136312 148402
elsif ($attr_info->{'is_num'}) { } 682 135630 136312
elsif ($attr_info->{'is_int_or_string'}) { } 773 134857 135630
elsif ($attr_info->{'is_str'}) { } 79244 55613 134857
elsif ($attr_info->{'is_quantity'} or $attr_info->{'is_time'}) { } 6808 48805 55613
elsif ($attr_info->{'is_object'} and builtin::blessed($value) and $value->can('TO_JSON')) { } 20621 28184 48805
elsif ($attr_info->{'is_array_of_objects'}) { } 9665 18519 28184
elsif ($attr_info->{'is_hash_of_objects'}) { } 1577 16942 18519
elsif ($attr_info->{'is_hash_of_object_arrays'}) { } 232 16710 16942
elsif ($attr_info->{'is_hash_of_str_arrays'}) { } 105 16605 16710
elsif ($attr_info->{'is_hash_of_int'}) { } 24 16581 16605
elsif ($attr_info->{'is_hash_of_num'}) { } 5 16576 16581
elsif ($attr_info->{'is_hash_of_bool'}) { } 3 16573 16576
elsif ($attr_info->{'is_hash_of_int_or_string'}) { } 17 16556 16573
elsif ($attr_info->{'is_hash_of_quantity'} or $attr_info->{'is_hash_of_time'}) { } 736 15820 16556
elsif ($attr_info->{'is_hash_of_str'}) { } 5839 9981 15820
elsif ($attr_info->{'is_array_of_int'}) { } 120 9861 9981
elsif ($attr_info->{'is_array_of_num'}) { } 6 9855 9861
elsif ($attr_info->{'is_array_of_str'}) { } 7998 1857 9855
elsif ($attr_info->{'is_array_of_int_or_string'}) { } 14 1843 1857
elsif ($attr_info->{'is_array_of_quantity'} or $attr_info->{'is_array_of_time'}) { } 53 1790 1843
elsif ($attr_info->{'is_array_of_bool'}) { } 53 1737 1790
elsif (ref $value eq 'ARRAY') { } 33 1704 1737
elsif (ref $value eq 'HASH') { } 1704 0 1704
277 11716 ▶ $data{$key} = $value ? JSON::MaybeXS::true : JSON::MaybeXS::false;
Branch: 1 branch
BranchTrueFalseTotal
$value ? : 6003 5713 11716
278 } elsif ($attr_info->{is_int}) {
279 12090 $data{$key} = int($value);
280 } elsif ($attr_info->{is_num}) {
281 # A genuine JSON number (OpenAPI type: number). Numify so it
282 # serializes unquoted -- the fractional counterpart to is_int's
283 # int() (k68). Quantity stays a string; this is only for
284 # schemas that declare type: number.
285 682 $data{$key} = $value + 0;
286 } elsif ($attr_info->{is_int_or_string}) {
287 773 ▶ $data{$key} = ($value =~ /\A-?\d+\z/) ? int($value) : $value;
Branch: 1 branch
BranchTrueFalseTotal
$value =~ /\A-?\d+\z/ ? : 505 268 773
288 } elsif ($attr_info->{is_str}) {
289 # A JSON string on the wire whatever Perl scalar it holds (k145):
290 # JSON::MaybeXS encodes a numeric scalar as a JSON number, so
291 # EnvVar value => 8080 used to go out as 8080 where Kubernetes
292 # expects "8080". Interpolating builds a fresh string, so the
293 # object's own value is left as it was. A ref cannot pass the
294 # Str constraint; the guard only keeps one that got into the
295 # slot some other way on the old pass-through.
296 79244 ▶ $data{$key} = ref $value ? $value : "$value";
Branch: 1 branch
BranchTrueFalseTotal
ref $value ? : 0 79244 79244
297 ▶ } elsif ($attr_info->{is_quantity} || $attr_info->{is_time}) {
Condition100%3/3
$attr_info->{"is_quantity"} or $attr_info->{"is_time"}
l!l&&r!l&&!r
797601148805
MC/DC100%2/2
$attr_info->{"is_quantity"} or $attr_info->{"is_time"}
$attr_info->{"is_quantity"} $attr_info->{"is_time"}
Truth table100%3/3
A or B
A= $attr_info->{"is_quantity"}B= $attr_info->{"is_time"}
ABresult
1X1
011
000
298 # A JSON string, the form Kubernetes writes both in (k180): a
299 # numeric Perl value -- sizeLimit => 1 -- used to go out as a
300 # JSON number, while the same value in a [Quantity] array went
301 # out as "1" (k167). The API server accepts either.
302 6808 ▶ $data{$key} = ref $value ? $value : "$value";
Branch: 1 branch
BranchTrueFalseTotal
ref $value ? : 0 6808 6808
303 ▶ } elsif ($attr_info->{is_object} && blessed($value) && $value->can('TO_JSON')) {
Condition66%4/6
$attr_info->{"is_object"} and builtin::blessed($value) and $value->can("TO_JSON")
!ll&&!rl&&r
28184020621
$attr_info->{"is_object"} and builtin::blessed($value)
!ll&&!rl&&r
28184020621
MC/DC33%1/3
$attr_info->{"is_object"} and builtin::blessed($value) and $value->can("TO_JSON")
$attr_info->{"is_object"} builtin::blessed($value) $value->can("TO_JSON")
Truth table50%2/4
A and B and C
A= $attr_info->{"is_object"}B= builtin::blessed($value)C= $value->can("TO_JSON")
ABCresult
0XX0
10X0
1100
1111
304 20621 $data{$key} = $value->TO_JSON;
305 } elsif ($attr_info->{is_array_of_objects}) {
306 9665 $data{$key} = [ map { $_->TO_JSON } @$value ];
307 } elsif ($attr_info->{is_hash_of_objects}) {
308 1577 $data{$key} = { map { $_ => $value->{$_}->TO_JSON } keys %$value };
309 } elsif ($attr_info->{is_hash_of_object_arrays}) {
310 # map[string][]Object (k194): each list in a new array, each
311 # element serialized; a value the constructor never saw (a write
312 # through the accessor's hashref) that is not a list or an
313 # object goes out as it is.
314 $data{$key} = { map {
315 232 my $list = $value->{$_};
316 $_ => (ref $list eq 'ARRAY'
317 232 ▶ ? [ map { blessed($_) && $_->can('TO_JSON') ? $_->TO_JSON : $_ } @$list ]
Branch: 2 branches
BranchTrueFalseTotal
ref $list eq 'ARRAY' ? : 232 0 232
builtin::blessed($_) && $_->can('TO_JSON') ? : 236 0 236
Condition33%1/3
builtin::blessed($_) and $_->can("TO_JSON")
!ll&&!rl&&r
00236
MC/DC0%0/2
builtin::blessed($_) and $_->can("TO_JSON")
builtin::blessed($_) $_->can("TO_JSON")
Truth table33%1/3
A and B
A= builtin::blessed($_)B= $_->can("TO_JSON")
ABresult
0X0
100
111
318 : $list)
319 } keys %$value };
320 } elsif ($attr_info->{is_hash_of_str_arrays}) {
321 # map[string][]string (k194): every element a JSON string, the
322 # rule a [Str] element follows (k145), in new arrays (k54).
323 # undef and a reference element go out as they are.
324 $data{$key} = { map {
325 105 my $list = $value->{$_};
326 $_ => (ref $list eq 'ARRAY'
327 113 ▶ ? [ map { defined($_) && !ref($_) ? "$_" : $_ } @$list ]
Branch: 2 branches
BranchTrueFalseTotal
ref $list eq 'ARRAY' ? : 113 0 113
defined $_ && !ref($_) ? : 216 0 216
Condition33%1/3
defined $_ and not ref $_
!ll&&!rl&&r
00216
MC/DC0%0/2
defined $_ and not ref $_
defined $_ not ref $_
Truth table33%1/3
A and not(B)
A= defined $_B= not ref $_
ABresult
0X0
100
111
328 : $list)
329 } keys %$value };
330 } elsif ($attr_info->{is_hash_of_int}) {
331 24 $data{$key} = { map { $_ => int($value->{$_}) } keys %$value };
332 } elsif ($attr_info->{is_hash_of_num}) {
333 5 $data{$key} = { map { $_ => $value->{$_} + 0 } keys %$value };
334 } elsif ($attr_info->{is_hash_of_bool}) {
335 $data{$key} = { map {
336 3 ▶ $_ => $value->{$_} ? JSON::MaybeXS::true : JSON::MaybeXS::false
Branch: 1 branch
BranchTrueFalseTotal
$value->{$_} ? : 3 3 6
337 } keys %$value };
338 } elsif ($attr_info->{is_hash_of_int_or_string}) {
339 $data{$key} = { map {
340 17 my $v = $value->{$_};
341 28 ▶ $_ => (($v =~ /\A-?\d+\z/) ? int($v) : $v)
Branch: 1 branch
BranchTrueFalseTotal
$v =~ /\A-?\d+\z/ ? : 17 11 28
342 } keys %$value };
343 ▶ } elsif ($attr_info->{is_hash_of_quantity} || $attr_info->{is_hash_of_time}) {
Condition100%3/3
$attr_info->{"is_hash_of_quantity"} or $attr_info->{"is_hash_of_time"}
l!l&&r!l&&!r
7211515820
MC/DC100%2/2
$attr_info->{"is_hash_of_quantity"} or $attr_info->{"is_hash_of_time"}
$attr_info->{"is_hash_of_quantity"} $attr_info->{"is_hash_of_time"}
Truth table100%3/3
A or B
A= $attr_info->{"is_hash_of_quantity"}B= $attr_info->{"is_hash_of_time"}
ABresult
1X1
011
000
344 # Each value a JSON string, as for the scalar field (k180) --
345 # limits => { cpu => 1 } goes out as {"cpu":"1"} -- in a new
346 # hash (k54). A value the constructor never saw (written through
347 # the accessor's hashref) may be undef or a ref; it goes out as
348 # it is, the way the array branches below leave such elements.
349 $data{$key} = { map {
350 736 my $v = $value->{$_};
351 930 ▶ $_ => (defined($v) && !ref($v) ? "$v" : $v)
Branch: 1 branch
BranchTrueFalseTotal
defined $v && !ref($v) ? : 928 2 930
Condition100%3/3
defined $v and not ref $v
!ll&&!rl&&r
11928
MC/DC100%2/2
defined $v and not ref $v
defined $v not ref $v
Truth table100%3/3
A and not(B)
A= defined $vB= not ref $v
ABresult
0X0
100
111
352 } keys %$value };
353 } elsif ($attr_info->{is_hash_of_str}) {
354 # The string map (k191): every scalar value a JSON string, the
355 # rule a [Str] element follows (k145) -- labels => { v => 5 }
356 # used to go out as {"v":5} and the API server answered 400 --
357 # in a new hash (k54), the object keeping what it was given.
358 # undef and a reference go out as they are. A reference can only
359 # sit in the lenient { Str => 1 } form (HashRef[Str] refuses one
360 # at construction, but a write through the accessor's hashref
361 # can still put one there), and there it is the opaque-map use
362 # that form served until k191, so it is reported, once per class
363 # and field (_warn_lenient_ref).
364 5839 my %out;
365 5839 for my $k (keys %$value) {
366 6511 my $v = $value->{$k};
367 6511 ▶ if (ref $v) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $v) { } 6 6505 6511
368 _warn_lenient_ref(ref($self) || $self, $key, $k)
369 6 ▶ if $attr_info->{is_hash_of_str_lenient};
Branch: 1 branch
BranchTrueFalseTotal
if $attr_info->{"is_hash_of_str_lenient"} 6 0 6
Condition33%1/3
ref $self || $self
l!l&&r!l&&!r
600
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table33%1/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
370 6 $out{$k} = $v;
371 } else {
372 6505 ▶ $out{$k} = defined $v ? "$v" : $v;
Branch: 1 branch
BranchTrueFalseTotal
defined $v ? : 6505 0 6505
373 }
374 }
375 5839 $data{$key} = \%out;
376 } elsif ($attr_info->{is_array_of_int}) {
377 120 $data{$key} = [ map { int($_) } @$value ];
378 } elsif ($attr_info->{is_array_of_num}) {
379 # Each element a JSON number, as for is_num above (k68), so a
380 # numeric string passed to ->new does not go out quoted. Until
381 # AutoGen typed `items: {type: number}` as [Num] (k155) no class
382 # carried this form and the generic ARRAY copy below served it.
383 # An undef or ref element is left alone, as in is_array_of_str.
384 6 ▶ $data{$key} = [ map { defined($_) && !ref($_) ? $_ + 0 : $_ } @$value ];
Branch: 1 branch
BranchTrueFalseTotal
defined $_ && !ref($_) ? : 11 0 11
Condition33%1/3
defined $_ and not ref $_
!ll&&!rl&&r
0011
MC/DC0%0/2
defined $_ and not ref $_
defined $_ not ref $_
Truth table33%1/3
A and not(B)
A= defined $_B= not ref $_
ABresult
0X0
100
111
385 } elsif ($attr_info->{is_array_of_str}) {
386 # Each element a JSON string, as for is_str above (k145), in a
387 # new outer array -- the same one-level copy the generic ARRAY
388 # branch below makes (k54). An element the constructor never
389 # saw (spec_push, or a push onto the accessor's arrayref) may be
390 # undef or a ref; it goes out exactly as before.
391 7998 ▶ $data{$key} = [ map { defined($_) && !ref($_) ? "$_" : $_ } @$value ];
Branch: 1 branch
BranchTrueFalseTotal
defined $_ && !ref($_) ? : 15519 0 15519
Condition33%1/3
defined $_ and not ref $_
!ll&&!rl&&r
0015519
MC/DC0%0/2
defined $_ and not ref $_
defined $_ not ref $_
Truth table33%1/3
A and not(B)
A= defined $_B= not ref $_
ABresult
0X0
100
111
392 } elsif ($attr_info->{is_array_of_int_or_string}) {
393 # The scalar is_int_or_string rule per element (k167): an
394 # all-digit element goes out as a JSON number, anything else as
395 # it is -- so 8080 stays 8080 and '25%' stays '25%'. Until
396 # AutoGen typed int-or-string items as [IntOrStr] no generated
397 # class carried this form, and the generic ARRAY copy below
398 # served the hand-written ones without the rule. undef and ref
399 # elements are left alone, as in is_array_of_str.
400 $data{$key} = [ map {
401 14 ▶ defined($_) && !ref($_) && /\A-?\d+\z/ ? int($_) : $_
Branch: 1 branch
BranchTrueFalseTotal
defined $_ && !ref($_) && /\A-?\d+\z/ ? : 16 15 31
Condition83%5/6
defined $_ and not ref $_ and /\A-?\d+\z/
!ll&&!rl&&r
11416
defined $_ and not ref $_
!ll&&!rl&&r
1030
MC/DC66%2/3
defined $_ and not ref $_ and /\A-?\d+\z/
defined $_ not ref $_ /\A-?\d+\z/
Truth table75%3/4
A and not(B) and C
A= defined $_B= not ref $_C= /\A-?\d+\z/
ABCresult
0XX0
10X0
1100
1111
402 } @$value ];
403 ▶ } elsif ($attr_info->{is_array_of_quantity} || $attr_info->{is_array_of_time}) {
Condition100%3/3
$attr_info->{"is_array_of_quantity"} or $attr_info->{"is_array_of_time"}
l!l&&r!l&&!r
38151790
MC/DC100%2/2
$attr_info->{"is_array_of_quantity"} or $attr_info->{"is_array_of_time"}
$attr_info->{"is_array_of_quantity"} $attr_info->{"is_array_of_time"}
Truth table100%3/3
A or B
A= $attr_info->{"is_array_of_quantity"}B= $attr_info->{"is_array_of_time"}
ABresult
1X1
011
000
404 # A Quantity and a Time are JSON strings on the wire (k167) --
405 # the form Kubernetes writes both in -- so a numeric Perl
406 # element such as 1 for a Quantity goes out as "1", the same
407 # per-element stringification is_array_of_str applies (k145),
408 # in a new outer array (k54).
409 53 ▶ $data{$key} = [ map { defined($_) && !ref($_) ? "$_" : $_ } @$value ];
Branch: 1 branch
BranchTrueFalseTotal
defined $_ && !ref($_) ? : 91 2 93
Condition100%3/3
defined $_ and not ref $_
!ll&&!rl&&r
1191
MC/DC100%2/2
defined $_ and not ref $_
defined $_ not ref $_
Truth table100%3/3
A and not(B)
A= defined $_B= not ref $_
ABresult
0X0
100
111
410 } elsif ($attr_info->{is_array_of_bool}) {
411 # An undef ELEMENT dies rather than becoming a silent false
412 # (k51). ArrayRef[Bool] accepts undef because
413 # Types::Standard::Bool does, and _normalize_bool deliberately
414 # returns it via an explicit `return undef` so the array coercer
415 # keeps the position -- but there is nothing honest to put on the
416 # wire here. The attribute-level answer (k48: leave it unset,
417 # omit the field) does not apply inside an array, where omitting
418 # would shift every later element; and the only field of this
419 # shape upstream (Api::Resource::V1*::DeviceAttribute bools) is a
420 # "non-empty list of true/false values", so a JSON null would be
421 # schema-invalid too. Message names field and index, in the k42
422 # diagnostic style.
423 53 my @bools;
424 53 for my $i (0 .. $#$value) {
425 160 ▶ die 'Bool value must not be undef at element ' . $i
Branch: 1 branch
BranchTrueFalseTotal
unless defined $value->[$i] 9 151 160
Condition33%1/3
ref $self || $self
l!l&&r!l&&!r
900
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table33%1/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
426 . ' while serializing ' . (ref($self) || $self)
427 . " field $key\n" unless defined $value->[$i];
428 151 ▶ push @bools, $value->[$i] ? JSON::MaybeXS::true : JSON::MaybeXS::false;
Branch: 1 branch
BranchTrueFalseTotal
$value->[$i] ? : 87 64 151
429 }
430 44 $data{$key} = \@bools;
431 } elsif (ref $value eq 'ARRAY') {
432 # Shallow copy, one level (k54): the struct must not alias the
433 # object, or post-processing what TO_JSON returned silently edits
434 # the object and every later serialization. Deliberately one level
435 # only -- a nested structure under an opaque hash attribute
436 # (fieldsV1, a free-form HashRef) still shares its inner refs with
437 # the object. Same depth on the way in, in IO::K8s::_inflate_struct.
438 33 $data{$key} = [ @$value ];
439 } elsif (ref $value eq 'HASH') {
440 # Shallow copy, one level -- see the ARRAY branch above (k54).
441 1704 $data{$key} = { %$value };
442 } else {
443 0 $data{$key} = $value;
444 }
445 }
446  
447 # Unknown fields ride along (D1). Declared attributes win on a clash:
448 # the bag only fills keys nothing above has set.
449 47730 my $extra = $self->_unknown_fields;
450 47730 ▶ if ($extra && %$extra) {
Branch: 1 branch
BranchTrueFalseTotal
if ($extra and %$extra) 42 47688 47730
Condition66%2/3
$extra and %$extra
!ll&&!rl&&r
04768842
MC/DC50%1/2
$extra and %$extra
$extra %$extra
Truth table66%2/3
A and B
A= $extraB= %$extra
ABresult
0X0
100
111
451 42 for my $key (keys %$extra) {
452 47 ▶ next if exists $data{$key};
Branch: 1 branch
BranchTrueFalseTotal
if exists $data{$key} 1 46 47
453 46 $data{$key} = _copy_one_level($extra->{$key});
454 }
455 }
456 47730 return \%data;
457 }
458  
459 # The deprecation warning of the lenient string map (k191): a { Str => 1 }
460 # field holding a reference is an opaque map declared the pre-k191 way. Once
461 # per class and field for the life of the process, in the 'deprecated'
462 # category of the code that serialized it, so `no warnings 'deprecated'`
463 # there silences it and $SIG{__WARN__} sees it. Counted only when actually
464 # emitted: a serialization with the category switched off does not use up
465 # the one warning a later one should get.
466 160 my %_lenient_ref_warned;
467  
468 6 ▶sub _warn_lenient_ref {
Subroutine _warn_lenient_ref: called CC=3 SCAR=11.0
469 6 my ($class, $field, $map_key) = @_;
470 6 ▶ return if $_lenient_ref_warned{$class}{$field};
Branch: 1 branch
BranchTrueFalseTotal
if $_lenient_ref_warned{$class}{$field} 3 3 6
471 3 ▶ return unless warnings::enabled('deprecated');
Branch: 1 branch
BranchTrueFalseTotal
unless warnings::enabled("deprecated") 0 3 3
472 3 $_lenient_ref_warned{$class}{$field} = 1;
473 3 warnings::warn('deprecated', "IO::K8s: field '$field' of $class is declared "
474 . "{ Str => 1 }, a map of strings, but holds a reference (at key "
475 . "'$map_key'); it is passed through unchanged. If the field is not a "
476 . 'map of strings, declare it as Opaque or HashRef[...]');
477 }
478  
479  
480 8069 ▶sub to_json {
Subroutine to_json: called CC=1 SCAR=0.0
Pod documented
481 8069 my $self = shift;
482 8069 return $self->_json_encoder->encode($self->TO_JSON);
483 }
484  
485  
486 98 ▶sub TO_YAML {
Subroutine TO_YAML: called CC=1 SCAR=0.0
Pod documented
487 98 my $self = shift;
488 98 require YAML::PP;
489 # Dumping with all three schemas quotes the union of what each would
490 # resolve to a non-string; kubectl reads YAML 1.1 (go-yaml v2), so the
491 # JSON schema alone left True, yes, on, ~, 012 bare (k188). Typed
492 # values emit the same under all three: they share JSON's representers.
493 98 my $yp = YAML::PP->new(schema => [qw/JSON Core YAML1_1/], boolean => 'JSON::PP');
494 98 return $yp->dump_string($self->TO_JSON);
495 }
496  
497 96 ▶sub to_yaml {
Subroutine to_yaml: called CC=1 SCAR=0.0
Pod documented
498 96 my $self = shift;
499 96 return $self->TO_YAML;
500 }
501  
502  
503 # The inflation that FROM_HASH routes through lives on an IO::K8s instance,
504 # and FROM_HASH is a class method, so it borrows one shared default instance.
505 # That is sound because the only thing it uses the instance for is
506 # _struct_to_object_expanded(), which is handed class names taken straight out
507 # of the attribute registry -- already fully expanded, so no resource_map, no
508 # class_namespaces and no openapi_spec of any *particular* IO::K8s instance is
509 # consulted. A caller who needs their own providers to take part in the
510 # resolution has $k8s->inflate / ->json_to_object, which start from a Kind.
511 #
512 # `require`, not a top-level `use`: IO::K8s loads IO::K8s::Resource, which
513 # loads this role, so a compile-time use here would close a load cycle.
514 5069 ▶sub _default_k8s {
Subroutine _default_k8s: called CC=1 SCAR=0.0
515 5069 require IO::K8s;
516 5069 state $k8s = IO::K8s->new;
517 5069 return $k8s;
518 }
519  
520  
521 122 ▶sub FROM_HASH {
Subroutine FROM_HASH: called CC=1 SCAR=0.0
Pod documented
522 122 my ($class, $hash) = @_;
523 122 return _default_k8s()->_struct_to_object_expanded($class, $hash);
524 }
525  
526  
527 23 ▶sub from_json {
Subroutine from_json: called CC=1 SCAR=0.0
Pod documented
528 23 my ($class, $json_str) = @_;
529 23 state $json = JSON::MaybeXS->new(utf8 => 1);
530 23 return $class->FROM_HASH($json->decode($json_str));
531 }
532  
533  
534 # Compare local class attributes against OpenAPI schema
535 # Returns hashref with differences:
536 # missing_locally => [ attrs in schema but not in class ]
537 # missing_in_schema => [ attrs in class but not in schema ]
538 # type_mismatch => [ { attr => $name, local => $type, schema => $type } ]
539 3 ▶sub compare_to_schema {
Subroutine compare_to_schema: called CC=16 SCAR=30.0
Pod documented
540 3 my ($class, $schema) = @_;
541 3 ▶ $class = ref($class) if ref($class);
Branch: 1 branch
BranchTrueFalseTotal
if ref $class 0 3 3
542  
543 # Use the merged @ISA view (same structure as the raw registry entry:
544 # json_key plus type flags) so a class_namespaces-style subclass sees its
545 # inherited attributes instead of an empty or partial registry entry.
546 3 my $local_attrs = _k8s_attr_info($class);
547 3 ▶ my $schema_props = $schema->{properties} // {};
Condition50%1/2
$schema->{"properties"} // {}
l!l
30
MC/DC0%0/1
$schema->{"properties"} // {}
$schema->{"properties"}
Truth table50%1/2
A
A= $schema->{"properties"}
Aresult
11
00
548  
549 # Build json_key -> attr_name mapping for lookup
550 3 my %json_to_attr;
551 3 for my $attr (keys %$local_attrs) {
552 13 ▶ my $jk = $local_attrs->{$attr}{json_key} // $attr;
Condition33%1/3
$local_attrs->{$attr}{"json_key"} // $attr
l!l&&r!l&&!r
0130
MC/DC0%0/2
$local_attrs->{$attr}{"json_key"} // $attr
$local_attrs->{$attr}{"json_key"} $attr
Truth table33%1/3
A // B
A= $local_attrs->{$attr}{"json_key"}B= $attr
ABresult
1X1
011
000
553 13 $json_to_attr{$jk} = $attr;
554 }
555  
556 3 my %result = (
557 missing_locally => [],
558 missing_in_schema => [],
559 type_mismatch => [],
560 );
561  
562 # Check schema properties against local attributes
563 3 for my $prop (keys %$schema_props) {
564 12 my $attr = $json_to_attr{$prop};
565 12 ▶ if (!defined $attr) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $attr) { } 1 11 12
566 # Special case: metadata comes from Role, not k8s DSL
567 1 ▶ next if $prop eq 'metadata' && $class->can('metadata');
Branch: 1 branch
BranchTrueFalseTotal
if $prop eq "metadata" and $class->can("metadata") 0 1 1
Condition33%1/3
$prop eq "metadata" and $class->can("metadata")
!ll&&!rl&&r
100
MC/DC0%0/2
$prop eq "metadata" and $class->can("metadata")
$prop eq "metadata" $class->can("metadata")
Truth table33%1/3
A and B
A= $prop eq "metadata"B= $class->can("metadata")
ABresult
0X0
100
111
568 # apiVersion and kind also come from Role
569 1 ▶ next if ($prop eq 'apiVersion' || $prop eq 'kind') && $class->can('_is_resource');
Branch: 1 branch
BranchTrueFalseTotal
if $prop eq "apiVersion" || $prop eq "kind" and $class->can("_is_resource") 0 1 1
Condition33%2/6
$prop eq "apiVersion" || $prop eq "kind" and $class->can("_is_resource")
!ll&&!rl&&r
100
$prop eq "apiVersion" or $prop eq "kind"
l!l&&r!l&&!r
001
MC/DC0%0/3
$prop eq "apiVersion" || $prop eq "kind" and $class->can("_is_resource")
$prop eq "apiVersion" $prop eq "kind" $class->can("_is_resource")
Truth table20%1/5
A or B and C
A= $prop eq "apiVersion"B= $prop eq "kind"C= $class->can("_is_resource")
ABCresult
00X0
1X00
0100
1X11
0111
570 1 push @{$result{missing_locally}}, $prop;
571 } else {
572 # Compare types
573 11 my $local_type = _describe_local_type($local_attrs->{$attr});
574 11 my $schema_type = _describe_schema_type($schema_props->{$prop});
575 11 ▶ if ($local_type ne $schema_type) {
Branch: 1 branch
BranchTrueFalseTotal
if ($local_type ne $schema_type) 1 10 11
576 1 push @{$result{type_mismatch}}, {
577 attr => $prop,
578 local => $local_type,
579 schema => $schema_type,
580 };
581 }
582 }
583 }
584  
585 # Check local attributes not in schema
586 3 for my $attr (keys %$local_attrs) {
587 13 ▶ my $jk = $local_attrs->{$attr}{json_key} // $attr;
Condition33%1/3
$local_attrs->{$attr}{"json_key"} // $attr
l!l&&r!l&&!r
0130
MC/DC0%0/2
$local_attrs->{$attr}{"json_key"} // $attr
$local_attrs->{$attr}{"json_key"} $attr
Truth table33%1/3
A // B
A= $local_attrs->{$attr}{"json_key"}B= $attr
ABresult
1X1
011
000
588 13 ▶ if (!exists $schema_props->{$jk}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $schema_props->{$jk}) 2 11 13
589 2 push @{$result{missing_in_schema}}, $jk;
590 }
591 }
592  
593 3 return \%result;
594 }
595  
596 11 ▶sub _describe_local_type {
Subroutine _describe_local_type: called CC=20 SCAR=50.4
597 11 my ($info) = @_;
598 11 ▶ return 'string' if $info->{is_str};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_str"} 6 5 11
599 5 ▶ return 'integer' if $info->{is_int};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_int"} 0 5 5
600 5 ▶ return 'number' if $info->{is_num};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_num"} 0 5 5
601 5 ▶ return 'int-or-string' if $info->{is_int_or_string};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_int_or_string"} 0 5 5
602 5 ▶ return 'quantity' if $info->{is_quantity};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_quantity"} 1 4 5
603 4 ▶ return 'date-time' if $info->{is_time};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_time"} 3 1 4
604 1 ▶ return 'boolean' if $info->{is_bool};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_bool"} 1 0 1
605 0 ▶ return 'array<string>' if $info->{is_array_of_str};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_array_of_str"} 0 0 0
606 0 ▶ return 'array<integer>' if $info->{is_array_of_int};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_array_of_int"} 0 0 0
607 0 ▶ return 'array<number>' if $info->{is_array_of_num};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_array_of_num"} 0 0 0
608 0 ▶ return 'array<boolean>' if $info->{is_array_of_bool};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_array_of_bool"} 0 0 0
609 0 ▶ return 'array<object>' if $info->{is_array_of_objects};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_array_of_objects"} 0 0 0
610 0 ▶ return 'hash<string>' if $info->{is_hash_of_str};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_hash_of_str"} 0 0 0
611 0 ▶ return 'hash<array<string>>' if $info->{is_hash_of_str_arrays};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_hash_of_str_arrays"} 0 0 0
612 0 ▶ return 'hash<array<object>>' if $info->{is_hash_of_object_arrays};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_hash_of_object_arrays"} 0 0 0
613 0 ▶ return 'hash<number>' if $info->{is_hash_of_num};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_hash_of_num"} 0 0 0
614 0 ▶ return 'hash<object>' if $info->{is_hash_of_objects};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_hash_of_objects"} 0 0 0
615 0 ▶ return 'object' if $info->{is_hash_opaque};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_hash_opaque"} 0 0 0
616 0 ▶ return 'object' if $info->{is_object};
Branch: 1 branch
BranchTrueFalseTotal
if $info->{"is_object"} 0 0 0
617 0 return 'unknown';
618 }
619  
620 11 ▶sub _describe_schema_type {
Subroutine _describe_schema_type: called CC=17 SCAR=40.5
621 11 my ($prop) = @_;
622 11 ▶ if (my $ref = $prop->{'$ref'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $ref = $prop->{"\$ref"}) 3 8 11
623 3 ▶ return 'int-or-string' if $ref =~ /intstr\.IntOrString$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ref =~ /intstr\.IntOrString$/ 0 3 3
624 3 ▶ return 'quantity' if $ref =~ /resource\.Quantity$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ref =~ /resource\.Quantity$/ 1 2 3
625 2 ▶ return 'date-time' if $ref =~ /meta\.v1\.(Micro)?Time$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ref =~ /meta\.v1\.(Micro)?Time$/ 2 0 2
626 0 return 'object';
627 }
628 8 ▶ my $type = $prop->{type} // 'unknown';
Condition50%1/2
$prop->{"type"} // "unknown"
l!l
80
MC/DC0%0/1
$prop->{"type"} // "unknown"
$prop->{"type"}
Truth table50%1/2
A
A= $prop->{"type"}
Aresult
11
00
629 8 ▶ my $format = $prop->{format} // '';
Condition100%2/2
$prop->{"format"} // ""
l!l
17
MC/DC100%1/1
$prop->{"format"} // ""
$prop->{"format"}
Truth table100%2/2
A
A= $prop->{"format"}
Aresult
11
00
630 8 ▶ return 'int-or-string' if $format eq 'int-or-string';
Branch: 1 branch
BranchTrueFalseTotal
if $format eq "int-or-string" 0 8 8
631 8 ▶ return 'date-time' if $format eq 'date-time';
Branch: 1 branch
BranchTrueFalseTotal
if $format eq "date-time" 1 7 8
632 7 ▶ if ($type eq 'array') {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq "array") 0 7 7
633 0 ▶ my $items = $prop->{items} // {};
Condition0%0/2
$prop->{"items"} // {}
l!l
00
MC/DC0%0/1
$prop->{"items"} // {}
$prop->{"items"}
Truth table0%0/2
A
A= $prop->{"items"}
Aresult
11
00
634 0 ▶ if ($items->{'$ref'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($items->{"\$ref"}) 0 0 0
635 0 return 'array<object>';
636 }
637 0 ▶ my $item_type = $items->{type} // 'unknown';
Condition0%0/2
$items->{"type"} // "unknown"
l!l
00
MC/DC0%0/1
$items->{"type"} // "unknown"
$items->{"type"}
Truth table0%0/2
A
A= $items->{"type"}
Aresult
11
00
638 0 return "array<$item_type>";
639 }
640 7 ▶ if ($type eq 'object' && $prop->{additionalProperties}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq "object" and $prop->{"additionalProperties"}) 0 7 7
Condition33%1/3
$type eq "object" and $prop->{"additionalProperties"}
!ll&&!rl&&r
700
MC/DC0%0/2
$type eq "object" and $prop->{"additionalProperties"}
$type eq "object" $prop->{"additionalProperties"}
Truth table33%1/3
A and B
A= $type eq "object"B= $prop->{"additionalProperties"}
ABresult
0X0
100
111
641 0 my $add = $prop->{additionalProperties};
642 0 ▶ if ($add->{'$ref'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($add->{"\$ref"}) 0 0 0
643 0 return 'hash<object>';
644 }
645 0 ▶ my $val_type = $add->{type} // 'unknown';
Condition0%0/2
$add->{"type"} // "unknown"
l!l
00
MC/DC0%0/1
$add->{"type"} // "unknown"
$add->{"type"}
Truth table0%0/2
A
A= $add->{"type"}
Aresult
11
00
646 0 return "hash<$val_type>";
647 }
648 7 return $type;
649 }
650  
651 160 1;
652  
653 __END__
« maint/crd-drift-check.pl ↑ Summary blib/lib/IO/K8s/AutoGen.pm »