blib/lib/IO/K8s.pm

filter: Statementstmt 97.8% 448 / 458 Branchbran 89.4% 254 / 284 Conditioncond 72.0% 111 / 154 MC/DCmcdc 55.5% 50 / 90 Subroutinesub 100% 59 / 59 Podpod 85.7% 12 / 14 totaltotal 88.2% 934 / 1059 CC 211 SCAR 24.4
CC
211
Cov
91%
new_object
26.8
expand_class
24.1
_inflate_struct
22.4
CRAP 11.5
« lib/IO/K8s/List.pm ↑ Summary blib/lib/IO/K8s/Role/SpecBuilder.pm »
1 package IO::K8s;
2 # ABSTRACT: Objects representing things found in the Kubernetes API
3  
4 148 ▶use v5.10;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 148 ▶use Moo;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 148 ▶use Carp qw(croak);
Subroutine BEGIN: called CC=1 SCAR=0.0
7 148 ▶use Module::Runtime qw(require_module);
Subroutine BEGIN: called CC=1 SCAR=0.0
8 148 ▶use JSON::MaybeXS;
Subroutine BEGIN: called CC=1 SCAR=0.0
9 148 ▶use Scalar::Util ();
Subroutine BEGIN: called CC=1 SCAR=0.0
10 148 ▶use IO::K8s::AutoGen;
Subroutine BEGIN: called CC=1 SCAR=0.0
11 148 ▶use IO::K8s::Resource ();
Subroutine BEGIN: called CC=1 SCAR=0.0
12 148 ▶use IO::K8s::Unstructured ();
Subroutine BEGIN: called CC=1 SCAR=0.0
13 148 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
14  
15 148 our $VERSION = '1.112';
16  
17 # Track which classes we've auto-generated
18 148 my %_autogen_cache;
19  
20 # Generated classes outlive their IO::K8s instance, so a freed instance's
21 # reusable object address cannot identify its namespace.
22 148 my $_autogen_namespace_sequence = 0;
23  
24 # Classes load_class() has already pulled in successfully.
25 #
26 # ONLY successes are recorded, and only after require_module has returned:
27 # a failed load dies before the store, so a name that was not loadable when
28 # it was first asked for is tried again on the next call. That is the whole
29 # point of not writing this as a plain memo of the outcome -- a negative
30 # entry would make a package that only becomes available later (defined at
31 # runtime and registered in %INC, or a module installed mid-process)
32 # permanently unloadable, and the resulting failure would depend on which
33 # lookup happened first.
34 148 my %_loaded_class;
35  
36 # Default resource map. Two kinds of key live here:
37 #
38 # 'Pod' short name: what new_object('Pod') and any lookup
39 # without an apiVersion resolve to. One per Kind, pointing
40 # at the newest stable shipped version.
41 # 'v1/Pod' domain-qualified '$api_version/$Kind': what inflate()
42 # dispatches on (it always passes the payload's apiVersion)
43 # and what expand_class($kind, $api_version) consults first.
44 # One per SHIPPED version of the Kind.
45 #
46 # Values are class paths relative to IO::K8s, or a full class name with a
47 # '+' prefix.
48 #
49 # Both key kinds are plain literals on purpose. The qualified ones used to
50 # be derived in BUILD by loading every target class to ask for its
51 # api_version(), which made IO::K8s->new pull in ~110 modules and cost
52 # ~0.4s even for a caller that only wanted a ConfigMap. The set is
53 # statically known, so it is written out. Writing it out also keeps the
54 # class-method path (IO::K8s->expand_class(...), which reads
55 # %DEFAULT_RESOURCE_MAP directly and never runs BUILD) in sync with what
56 # an instance sees. add() still introspects, because external providers
57 # are not known at compile time.
58 #
59 # Adding a Kind: one short name pointing at the newest stable shipped
60 # version, plus one qualified key per shipped version. Omitting the
61 # qualified key means an explicit GVK request fails closed, even when a
62 # bare compatibility alias exists for the Kind -- see k11 and k17.
63 #
64 # Deliberately absent: Kinds served only by CRD providers (those live in
65 # the provider's own resource_map, opt in via
66 # IO::K8s->new(with => [...])), and the upstream *TemplateSpec types
67 # (PodTemplateSpec, JobTemplateSpec, PersistentVolumeClaimTemplate,
68 # ResourceClaimTemplateSpec) -- they carry metadata but have no
69 # x-kubernetes-group-version-kind and never appear as a 'kind:' on the wire.
70 148 my %DEFAULT_RESOURCE_MAP = (
71 # -- Core (v1) ---------------------------------------------------------
72 Binding => 'Api::Core::V1::Binding',
73 ComponentStatus => 'Api::Core::V1::ComponentStatus',
74 ConfigMap => 'Api::Core::V1::ConfigMap',
75 Endpoints => 'Api::Core::V1::Endpoints',
76 Event => 'Api::Core::V1::Event',
77 LimitRange => 'Api::Core::V1::LimitRange',
78 Namespace => 'Api::Core::V1::Namespace',
79 Node => 'Api::Core::V1::Node',
80 PersistentVolume => 'Api::Core::V1::PersistentVolume',
81 PersistentVolumeClaim => 'Api::Core::V1::PersistentVolumeClaim',
82 Pod => 'Api::Core::V1::Pod',
83 PodTemplate => 'Api::Core::V1::PodTemplate',
84 ReplicationController => 'Api::Core::V1::ReplicationController',
85 ResourceQuota => 'Api::Core::V1::ResourceQuota',
86 Secret => 'Api::Core::V1::Secret',
87 Service => 'Api::Core::V1::Service',
88 ServiceAccount => 'Api::Core::V1::ServiceAccount',
89 'v1/Binding' => 'Api::Core::V1::Binding',
90 'v1/ComponentStatus' => 'Api::Core::V1::ComponentStatus',
91 'v1/ConfigMap' => 'Api::Core::V1::ConfigMap',
92 'v1/Endpoints' => 'Api::Core::V1::Endpoints',
93 'v1/Event' => 'Api::Core::V1::Event',
94 'v1/LimitRange' => 'Api::Core::V1::LimitRange',
95 'v1/Namespace' => 'Api::Core::V1::Namespace',
96 'v1/Node' => 'Api::Core::V1::Node',
97 'v1/PersistentVolume' => 'Api::Core::V1::PersistentVolume',
98 'v1/PersistentVolumeClaim' => 'Api::Core::V1::PersistentVolumeClaim',
99 'v1/Pod' => 'Api::Core::V1::Pod',
100 'v1/PodTemplate' => 'Api::Core::V1::PodTemplate',
101 'v1/ReplicationController' => 'Api::Core::V1::ReplicationController',
102 'v1/ResourceQuota' => 'Api::Core::V1::ResourceQuota',
103 'v1/Secret' => 'Api::Core::V1::Secret',
104 'v1/Service' => 'Api::Core::V1::Service',
105 'v1/ServiceAccount' => 'Api::Core::V1::ServiceAccount',
106 'events.k8s.io/v1/Event' => 'Api::Events::V1::Event',
107  
108 # -- Apps --------------------------------------------------------------
109 ControllerRevision => 'Api::Apps::V1::ControllerRevision',
110 DaemonSet => 'Api::Apps::V1::DaemonSet',
111 Deployment => 'Api::Apps::V1::Deployment',
112 ReplicaSet => 'Api::Apps::V1::ReplicaSet',
113 StatefulSet => 'Api::Apps::V1::StatefulSet',
114 'apps/v1/ControllerRevision' => 'Api::Apps::V1::ControllerRevision',
115 'apps/v1/DaemonSet' => 'Api::Apps::V1::DaemonSet',
116 'apps/v1/Deployment' => 'Api::Apps::V1::Deployment',
117 'apps/v1/ReplicaSet' => 'Api::Apps::V1::ReplicaSet',
118 'apps/v1/StatefulSet' => 'Api::Apps::V1::StatefulSet',
119  
120 # -- Batch -------------------------------------------------------------
121 CronJob => 'Api::Batch::V1::CronJob',
122 Job => 'Api::Batch::V1::Job',
123 'batch/v1/CronJob' => 'Api::Batch::V1::CronJob',
124 'batch/v1/Job' => 'Api::Batch::V1::Job',
125  
126 # -- Networking --------------------------------------------------------
127 IPAddress => 'Api::Networking::V1::IPAddress',
128 Ingress => 'Api::Networking::V1::Ingress',
129 IngressClass => 'Api::Networking::V1::IngressClass',
130 NetworkPolicy => 'Api::Networking::V1::NetworkPolicy',
131 ServiceCIDR => 'Api::Networking::V1::ServiceCIDR',
132 'networking.k8s.io/v1/IPAddress' => 'Api::Networking::V1::IPAddress',
133 'networking.k8s.io/v1/Ingress' => 'Api::Networking::V1::Ingress',
134 'networking.k8s.io/v1/IngressClass' => 'Api::Networking::V1::IngressClass',
135 'networking.k8s.io/v1/NetworkPolicy' => 'Api::Networking::V1::NetworkPolicy',
136 'networking.k8s.io/v1/ServiceCIDR' => 'Api::Networking::V1::ServiceCIDR',
137 'networking.k8s.io/v1beta1/IPAddress' => 'Api::Networking::V1beta1::IPAddress',
138 'networking.k8s.io/v1beta1/ServiceCIDR' => 'Api::Networking::V1beta1::ServiceCIDR',
139  
140 # -- Storage -----------------------------------------------------------
141 CSIDriver => 'Api::Storage::V1::CSIDriver',
142 CSINode => 'Api::Storage::V1::CSINode',
143 CSIStorageCapacity => 'Api::Storage::V1::CSIStorageCapacity',
144 StorageClass => 'Api::Storage::V1::StorageClass',
145 VolumeAttachment => 'Api::Storage::V1::VolumeAttachment',
146 VolumeAttributesClass => 'Api::Storage::V1::VolumeAttributesClass',
147 'storage.k8s.io/v1/CSIDriver' => 'Api::Storage::V1::CSIDriver',
148 'storage.k8s.io/v1/CSINode' => 'Api::Storage::V1::CSINode',
149 'storage.k8s.io/v1/CSIStorageCapacity' => 'Api::Storage::V1::CSIStorageCapacity',
150 'storage.k8s.io/v1/StorageClass' => 'Api::Storage::V1::StorageClass',
151 'storage.k8s.io/v1/VolumeAttachment' => 'Api::Storage::V1::VolumeAttachment',
152 'storage.k8s.io/v1/VolumeAttributesClass' => 'Api::Storage::V1::VolumeAttributesClass',
153 'storage.k8s.io/v1alpha1/VolumeAttributesClass' => 'Api::Storage::V1alpha1::VolumeAttributesClass',
154 'storage.k8s.io/v1beta1/VolumeAttributesClass' => 'Api::Storage::V1beta1::VolumeAttributesClass',
155  
156 # -- Resource (Dynamic Resource Allocation) ----------------------------
157 DeviceClass => 'Api::Resource::V1::DeviceClass',
158 DeviceTaintRule => 'Api::Resource::V1::DeviceTaintRule',
159 ResourceClaim => 'Api::Resource::V1::ResourceClaim',
160 ResourceClaimTemplate => 'Api::Resource::V1::ResourceClaimTemplate',
161 ResourcePoolStatusRequest => 'Api::Resource::V1alpha3::ResourcePoolStatusRequest',
162 ResourceSlice => 'Api::Resource::V1::ResourceSlice',
163 'resource.k8s.io/v1/DeviceClass' => 'Api::Resource::V1::DeviceClass',
164 'resource.k8s.io/v1/DeviceTaintRule' => 'Api::Resource::V1::DeviceTaintRule',
165 'resource.k8s.io/v1/ResourceClaim' => 'Api::Resource::V1::ResourceClaim',
166 'resource.k8s.io/v1/ResourceClaimTemplate' => 'Api::Resource::V1::ResourceClaimTemplate',
167 'resource.k8s.io/v1/ResourceSlice' => 'Api::Resource::V1::ResourceSlice',
168 'resource.k8s.io/v1alpha3/DeviceClass' => 'Api::Resource::V1alpha3::DeviceClass',
169 'resource.k8s.io/v1alpha3/DeviceTaintRule' => 'Api::Resource::V1alpha3::DeviceTaintRule',
170 'resource.k8s.io/v1alpha3/ResourceClaim' => 'Api::Resource::V1alpha3::ResourceClaim',
171 'resource.k8s.io/v1alpha3/ResourceClaimTemplate' => 'Api::Resource::V1alpha3::ResourceClaimTemplate',
172 'resource.k8s.io/v1alpha3/ResourcePoolStatusRequest' => 'Api::Resource::V1alpha3::ResourcePoolStatusRequest',
173 'resource.k8s.io/v1alpha3/ResourceSlice' => 'Api::Resource::V1alpha3::ResourceSlice',
174 'resource.k8s.io/v1beta1/DeviceClass' => 'Api::Resource::V1beta1::DeviceClass',
175 'resource.k8s.io/v1beta1/ResourceClaim' => 'Api::Resource::V1beta1::ResourceClaim',
176 'resource.k8s.io/v1beta1/ResourceClaimTemplate' => 'Api::Resource::V1beta1::ResourceClaimTemplate',
177 'resource.k8s.io/v1beta1/ResourceSlice' => 'Api::Resource::V1beta1::ResourceSlice',
178 'resource.k8s.io/v1beta2/DeviceClass' => 'Api::Resource::V1beta2::DeviceClass',
179 'resource.k8s.io/v1beta2/DeviceTaintRule' => 'Api::Resource::V1beta2::DeviceTaintRule',
180 'resource.k8s.io/v1beta2/ResourceClaim' => 'Api::Resource::V1beta2::ResourceClaim',
181 'resource.k8s.io/v1beta2/ResourceClaimTemplate' => 'Api::Resource::V1beta2::ResourceClaimTemplate',
182 'resource.k8s.io/v1beta2/ResourceSlice' => 'Api::Resource::V1beta2::ResourceSlice',
183  
184 # -- Authorization -----------------------------------------------------
185 LocalSubjectAccessReview => 'Api::Authorization::V1::LocalSubjectAccessReview',
186 SelfSubjectAccessReview => 'Api::Authorization::V1::SelfSubjectAccessReview',
187 SelfSubjectRulesReview => 'Api::Authorization::V1::SelfSubjectRulesReview',
188 SubjectAccessReview => 'Api::Authorization::V1::SubjectAccessReview',
189 'authorization.k8s.io/v1/LocalSubjectAccessReview' => 'Api::Authorization::V1::LocalSubjectAccessReview',
190 'authorization.k8s.io/v1/SelfSubjectAccessReview' => 'Api::Authorization::V1::SelfSubjectAccessReview',
191 'authorization.k8s.io/v1/SelfSubjectRulesReview' => 'Api::Authorization::V1::SelfSubjectRulesReview',
192 'authorization.k8s.io/v1/SubjectAccessReview' => 'Api::Authorization::V1::SubjectAccessReview',
193  
194 # -- Authentication ----------------------------------------------------
195 SelfSubjectReview => 'Api::Authentication::V1::SelfSubjectReview',
196 TokenRequest => 'Api::Authentication::V1::TokenRequest',
197 TokenReview => 'Api::Authentication::V1::TokenReview',
198 'authentication.k8s.io/v1/SelfSubjectReview' => 'Api::Authentication::V1::SelfSubjectReview',
199 'authentication.k8s.io/v1/TokenRequest' => 'Api::Authentication::V1::TokenRequest',
200 'authentication.k8s.io/v1/TokenReview' => 'Api::Authentication::V1::TokenReview',
201 'authentication.k8s.io/v1alpha1/SelfSubjectReview' => 'Api::Authentication::V1alpha1::SelfSubjectReview',
202 'authentication.k8s.io/v1beta1/SelfSubjectReview' => 'Api::Authentication::V1beta1::SelfSubjectReview',
203  
204 # -- RBAC --------------------------------------------------------------
205 ClusterRole => 'Api::Rbac::V1::ClusterRole',
206 ClusterRoleBinding => 'Api::Rbac::V1::ClusterRoleBinding',
207 Role => 'Api::Rbac::V1::Role',
208 RoleBinding => 'Api::Rbac::V1::RoleBinding',
209 'rbac.authorization.k8s.io/v1/ClusterRole' => 'Api::Rbac::V1::ClusterRole',
210 'rbac.authorization.k8s.io/v1/ClusterRoleBinding' => 'Api::Rbac::V1::ClusterRoleBinding',
211 'rbac.authorization.k8s.io/v1/Role' => 'Api::Rbac::V1::Role',
212 'rbac.authorization.k8s.io/v1/RoleBinding' => 'Api::Rbac::V1::RoleBinding',
213  
214 # -- Policy ------------------------------------------------------------
215 Eviction => 'Api::Policy::V1::Eviction',
216 PodDisruptionBudget => 'Api::Policy::V1::PodDisruptionBudget',
217 'policy/v1/Eviction' => 'Api::Policy::V1::Eviction',
218 'policy/v1/PodDisruptionBudget' => 'Api::Policy::V1::PodDisruptionBudget',
219  
220 # -- Autoscaling -------------------------------------------------------
221 HorizontalPodAutoscaler => 'Api::Autoscaling::V2::HorizontalPodAutoscaler',
222 Scale => 'Api::Autoscaling::V1::Scale',
223 'autoscaling/v1/HorizontalPodAutoscaler' => 'Api::Autoscaling::V1::HorizontalPodAutoscaler',
224 'autoscaling/v1/Scale' => 'Api::Autoscaling::V1::Scale',
225 'autoscaling/v2/HorizontalPodAutoscaler' => 'Api::Autoscaling::V2::HorizontalPodAutoscaler',
226  
227 # -- Certificates ------------------------------------------------------
228 CertificateSigningRequest => 'Api::Certificates::V1::CertificateSigningRequest',
229 ClusterTrustBundle => 'Api::Certificates::V1::ClusterTrustBundle',
230 PodCertificateRequest => 'Api::Certificates::V1::PodCertificateRequest',
231 'certificates.k8s.io/v1/CertificateSigningRequest' => 'Api::Certificates::V1::CertificateSigningRequest',
232 'certificates.k8s.io/v1/ClusterTrustBundle' => 'Api::Certificates::V1::ClusterTrustBundle',
233 'certificates.k8s.io/v1/PodCertificateRequest' => 'Api::Certificates::V1::PodCertificateRequest',
234 'certificates.k8s.io/v1alpha1/ClusterTrustBundle' => 'Api::Certificates::V1alpha1::ClusterTrustBundle',
235 'certificates.k8s.io/v1beta1/ClusterTrustBundle' => 'Api::Certificates::V1beta1::ClusterTrustBundle',
236 'certificates.k8s.io/v1beta1/PodCertificateRequest' => 'Api::Certificates::V1beta1::PodCertificateRequest',
237  
238 # -- Coordination ------------------------------------------------------
239 Lease => 'Api::Coordination::V1::Lease',
240 LeaseCandidate => 'Api::Coordination::V1beta1::LeaseCandidate',
241 'coordination.k8s.io/v1/Lease' => 'Api::Coordination::V1::Lease',
242 'coordination.k8s.io/v1alpha1/LeaseCandidate' => 'Api::Coordination::V1alpha1::LeaseCandidate',
243 'coordination.k8s.io/v1alpha2/LeaseCandidate' => 'Api::Coordination::V1alpha2::LeaseCandidate',
244 'coordination.k8s.io/v1beta1/LeaseCandidate' => 'Api::Coordination::V1beta1::LeaseCandidate',
245  
246 # -- Discovery ---------------------------------------------------------
247 EndpointSlice => 'Api::Discovery::V1::EndpointSlice',
248 'discovery.k8s.io/v1/EndpointSlice' => 'Api::Discovery::V1::EndpointSlice',
249  
250 # -- Scheduling --------------------------------------------------------
251 CompositePodGroup => 'Api::Scheduling::V1alpha3::CompositePodGroup',
252 PodGroup => 'Api::Scheduling::V1beta1::PodGroup',
253 PriorityClass => 'Api::Scheduling::V1::PriorityClass',
254 Workload => 'Api::Scheduling::V1beta1::Workload',
255 'scheduling.k8s.io/v1/PriorityClass' => 'Api::Scheduling::V1::PriorityClass',
256 'scheduling.k8s.io/v1alpha2/PodGroup' => 'Api::Scheduling::V1alpha2::PodGroup',
257 'scheduling.k8s.io/v1alpha2/Workload' => 'Api::Scheduling::V1alpha2::Workload',
258 'scheduling.k8s.io/v1alpha3/CompositePodGroup' => 'Api::Scheduling::V1alpha3::CompositePodGroup',
259 'scheduling.k8s.io/v1alpha3/PodGroup' => 'Api::Scheduling::V1alpha3::PodGroup',
260 'scheduling.k8s.io/v1alpha3/Workload' => 'Api::Scheduling::V1alpha3::Workload',
261 'scheduling.k8s.io/v1beta1/PodGroup' => 'Api::Scheduling::V1beta1::PodGroup',
262 'scheduling.k8s.io/v1beta1/Workload' => 'Api::Scheduling::V1beta1::Workload',
263  
264 # -- Node --------------------------------------------------------------
265 RuntimeClass => 'Api::Node::V1::RuntimeClass',
266 'node.k8s.io/v1/RuntimeClass' => 'Api::Node::V1::RuntimeClass',
267  
268 # -- Flowcontrol -------------------------------------------------------
269 FlowSchema => 'Api::Flowcontrol::V1::FlowSchema',
270 PriorityLevelConfiguration => 'Api::Flowcontrol::V1::PriorityLevelConfiguration',
271 'flowcontrol.apiserver.k8s.io/v1/FlowSchema' => 'Api::Flowcontrol::V1::FlowSchema',
272 'flowcontrol.apiserver.k8s.io/v1/PriorityLevelConfiguration' => 'Api::Flowcontrol::V1::PriorityLevelConfiguration',
273 'flowcontrol.apiserver.k8s.io/v1beta3/FlowSchema' => 'Api::Flowcontrol::V1beta3::FlowSchema',
274 'flowcontrol.apiserver.k8s.io/v1beta3/PriorityLevelConfiguration' => 'Api::Flowcontrol::V1beta3::PriorityLevelConfiguration',
275  
276 # -- Admissionregistration ---------------------------------------------
277 MutatingAdmissionPolicy => 'Api::Admissionregistration::V1::MutatingAdmissionPolicy',
278 MutatingAdmissionPolicyBinding => 'Api::Admissionregistration::V1::MutatingAdmissionPolicyBinding',
279 MutatingWebhookConfiguration => 'Api::Admissionregistration::V1::MutatingWebhookConfiguration',
280 ValidatingAdmissionPolicy => 'Api::Admissionregistration::V1::ValidatingAdmissionPolicy',
281 ValidatingAdmissionPolicyBinding => 'Api::Admissionregistration::V1::ValidatingAdmissionPolicyBinding',
282 ValidatingWebhookConfiguration => 'Api::Admissionregistration::V1::ValidatingWebhookConfiguration',
283 'admissionregistration.k8s.io/v1/MutatingAdmissionPolicy' => 'Api::Admissionregistration::V1::MutatingAdmissionPolicy',
284 'admissionregistration.k8s.io/v1/MutatingAdmissionPolicyBinding' => 'Api::Admissionregistration::V1::MutatingAdmissionPolicyBinding',
285 'admissionregistration.k8s.io/v1/MutatingWebhookConfiguration' => 'Api::Admissionregistration::V1::MutatingWebhookConfiguration',
286 'admissionregistration.k8s.io/v1/ValidatingAdmissionPolicy' => 'Api::Admissionregistration::V1::ValidatingAdmissionPolicy',
287 'admissionregistration.k8s.io/v1/ValidatingAdmissionPolicyBinding' => 'Api::Admissionregistration::V1::ValidatingAdmissionPolicyBinding',
288 'admissionregistration.k8s.io/v1/ValidatingWebhookConfiguration' => 'Api::Admissionregistration::V1::ValidatingWebhookConfiguration',
289 'admissionregistration.k8s.io/v1alpha1/MutatingAdmissionPolicy' => 'Api::Admissionregistration::V1alpha1::MutatingAdmissionPolicy',
290 'admissionregistration.k8s.io/v1alpha1/MutatingAdmissionPolicyBinding' => 'Api::Admissionregistration::V1alpha1::MutatingAdmissionPolicyBinding',
291 'admissionregistration.k8s.io/v1alpha1/ValidatingAdmissionPolicy' => 'Api::Admissionregistration::V1alpha1::ValidatingAdmissionPolicy',
292 'admissionregistration.k8s.io/v1alpha1/ValidatingAdmissionPolicyBinding' => 'Api::Admissionregistration::V1alpha1::ValidatingAdmissionPolicyBinding',
293 'admissionregistration.k8s.io/v1beta1/MutatingAdmissionPolicy' => 'Api::Admissionregistration::V1beta1::MutatingAdmissionPolicy',
294 'admissionregistration.k8s.io/v1beta1/MutatingAdmissionPolicyBinding' => 'Api::Admissionregistration::V1beta1::MutatingAdmissionPolicyBinding',
295 'admissionregistration.k8s.io/v1beta1/ValidatingAdmissionPolicy' => 'Api::Admissionregistration::V1beta1::ValidatingAdmissionPolicy',
296 'admissionregistration.k8s.io/v1beta1/ValidatingAdmissionPolicyBinding' => 'Api::Admissionregistration::V1beta1::ValidatingAdmissionPolicyBinding',
297  
298 # -- Lifecycle ---------------------------------------------------------
299 # Eviction is a collision Kind: the bare short name stays with the
300 # established policy/v1 Eviction, so lifecycle.k8s.io's Eviction is
301 # reachable by its qualified GVK only.
302 EvictionRequest => 'Api::Lifecycle::V1alpha1::EvictionRequest',
303 'lifecycle.k8s.io/v1alpha1/Eviction' => 'Api::Lifecycle::V1alpha1::Eviction',
304 'lifecycle.k8s.io/v1alpha1/EvictionRequest' => 'Api::Lifecycle::V1alpha1::EvictionRequest',
305  
306 # -- Storage version migration -----------------------------------------
307 StorageVersionMigration => 'Api::Storagemigration::V1::StorageVersionMigration',
308 'storagemigration.k8s.io/v1/StorageVersionMigration' => 'Api::Storagemigration::V1::StorageVersionMigration',
309 'storagemigration.k8s.io/v1alpha1/StorageVersionMigration' => 'Api::Storagemigration::V1alpha1::StorageVersionMigration',
310 'storagemigration.k8s.io/v1beta1/StorageVersionMigration' => 'Api::Storagemigration::V1beta1::StorageVersionMigration',
311  
312 # -- Internal apiserver ------------------------------------------------
313 StorageVersion => 'Api::Apiserverinternal::V1alpha1::StorageVersion',
314 'internal.apiserver.k8s.io/v1alpha1/StorageVersion' => 'Api::Apiserverinternal::V1alpha1::StorageVersion',
315  
316 # -- Extension APIs (different base paths) -----------------------------
317 APIService => 'KubeAggregator::Pkg::Apis::Apiregistration::V1::APIService',
318 CustomResourceDefinition => 'ApiextensionsApiserver::Pkg::Apis::Apiextensions::V1::CustomResourceDefinition',
319 'apiextensions.k8s.io/v1/CustomResourceDefinition' => 'ApiextensionsApiserver::Pkg::Apis::Apiextensions::V1::CustomResourceDefinition',
320 'apiregistration.k8s.io/v1/APIService' => 'KubeAggregator::Pkg::Apis::Apiregistration::V1::APIService',
321 );
322  
323 931 ▶has json => (is => 'ro', default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
324 931 return JSON::MaybeXS->new(utf8 => 1, canonical => 1);
325 148 });
326  
327 # Resource map - can be customized per instance
328 # Returns a copy so add() can safely mutate without affecting other instances
329 has resource_map => (
330 is => 'ro',
331 lazy => 1,
332 451 ▶ default => sub { +{ %DEFAULT_RESOURCE_MAP } },
Subroutine __ANON__: called CC=1 SCAR=0.0
333 148 );
334  
335 # OpenAPI spec for auto-generating unknown types
336 148 has openapi_spec => (
337 is => 'ro',
338 predicate => 1,
339 );
340  
341 # External resource map providers to merge at construction time
342 # e.g. with => ['IO::K8s::Cilium'] or with => [IO::K8s::Cilium->new]
343 has with => (
344 is => 'ro',
345 760 ▶ default => sub { [] },
Subroutine __ANON__: called CC=1 SCAR=0.0
346 148 );
347  
348 # Unknown-field policy for this instance's entry points (D1). 0: a field no
349 # class declares is kept and emitted again by TO_JSON. 1: it dies naming the
350 # class and the field. Applied by localizing $IO::K8s::Resource::STRICT in
351 # inflate, new_object, json_to_object and struct_to_object, so it reaches
352 # every nested constructor -- including the inline-struct coercers, which
353 # never pass through _inflate_struct. load and load_yaml inherit it through
354 # new_object / inflate.
355 has strict => (
356 is => 'ro',
357 917 ▶ default => sub { 0 },
Subroutine __ANON__: called CC=1 SCAR=0.0
358 148 );
359  
360 # Unknown-Kind policy (D4). '': the current fail-closed default -- inflate
361 # and new_object die with the GVK resolution error below when apiVersion/kind
362 # resolves to no registered class (built-in, CRD-registered, or AutoGen'd).
363 # 'unstructured': build an IO::K8s::Unstructured from the document instead of
364 # dying. Any other value keeps the fail-closed default unchanged -- only the
365 # literal string 'unstructured' opts in.
366 has unknown_kinds => (
367 is => 'ro',
368 925 ▶ default => sub { '' },
Subroutine __ANON__: called CC=1 SCAR=0.0
369 148 );
370  
371 # User namespaces to search for pre-built classes (checked before IO::K8s::)
372 # e.g. ['MyProject::K8s'] will look for MyProject::K8s::HelmChart before IO::K8s::...
373 has class_namespaces => (
374 is => 'ro',
375 926 ▶ default => sub { [] },
Subroutine __ANON__: called CC=1 SCAR=0.0
376 148 );
377  
378 # Internal: unique autogen namespace for this instance (isolated, collision-free)
379 has _autogen_namespace => (
380 is => 'ro',
381 lazy => 1,
382 46 ▶ default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
383 # A process-wide sequence remains unique after an instance is freed.
384 46 my $id = sprintf('%x', ++$_autogen_namespace_sequence);
385 46 return "IO::K8s::_AUTOGEN_$id";
386 },
387 148 );
388  
389 # Class method to get default resource map
390 10 ▶sub default_resource_map { \%DEFAULT_RESOURCE_MAP }
Subroutine default_resource_map: called CC=1 SCAR=0.0
Pod undocumented
391  
392 931 ▶sub BUILD {
Subroutine BUILD: called CC=2 SCAR=6.9
Pod undocumented
393 931 my ($self) = @_;
394  
395 # The built-in map already carries its domain-qualified keys as
396 # literals (see %DEFAULT_RESOURCE_MAP above), so there is nothing to
397 # derive here. Only external providers need introspecting, and add()
398 # does that itself.
399 931 ▶ $self->add(@{$self->with}) if @{$self->with};
Branch: 1 branch
BranchTrueFalseTotal
if @{$self->with;} 171 760 931
400 }
401  
402 # Add a '$api_version/$kind' qualified entry to $map if the target class
403 # can be loaded and reports an api_version. No-op if the qualified key
404 # already exists. Only used by add(): the built-in map spells its
405 # qualified keys out as literals, but an external provider's classes are
406 # not known until it is merged, so those have to be introspected.
407 2726 ▶sub _qualify_class_path {
Subroutine _qualify_class_path: called CC=8 SCAR=20.9
408 2726 my ($map, $kind, $class_path) = @_;
409  
410 # A key that already carries a '/' is an exact GVK request, not a bare
411 # Kind: it is meant to be registered verbatim (see the GatewayAPI
412 # ReferenceGrant and AgentSandbox entries). Re-qualifying it would build a
413 # junk "$group/$version/$group/$version/$Kind" key (k61).
414 2726 ▶ return if $kind =~ m{/};
Branch: 1 branch
BranchTrueFalseTotal
if $kind =~ m[/] 518 2208 2726
415  
416 2208 ▶ my $full_class = $class_path =~ /^\+/
Branch: 1 branch
BranchTrueFalseTotal
$class_path =~ /^\+/ ? : 84 2124 2208
417 ? substr($class_path, 1) : "IO::K8s::$class_path";
418  
419 2208 ▶ return unless _class_exists($full_class) && $full_class->can('api_version');
Branch: 1 branch
BranchTrueFalseTotal
unless _class_exists($full_class) and $full_class->can("api_version") 0 2208 2208
Condition33%1/3
_class_exists($full_class) and $full_class->can("api_version")
!ll&&!rl&&r
002208
MC/DC0%0/2
_class_exists($full_class) and $full_class->can("api_version")
_class_exists($full_class) $full_class->can("api_version")
Truth table33%1/3
A and B
A= _class_exists($full_class)B= $full_class->can("api_version")
ABresult
0X0
100
111
420 # Ask as a class method, but only accept an answer that comes back without
421 # error (same guard as IO::K8s::List::api_version). An external provider's
422 # class may implement api_version as an instance attribute rather than a
423 # constant, in which case the class-method call dies -- skip qualifying it
424 # instead of letting add() blow up.
425 2208 my $api_version = eval { $full_class->api_version };
426 2208 ▶ return if $@;
Branch: 1 branch
BranchTrueFalseTotal
if $@ 2 2206 2208
427 2206 ▶ return unless $api_version;
Branch: 1 branch
BranchTrueFalseTotal
unless $api_version 2 2204 2206
428  
429 2204 my $qkey = "$api_version/$kind";
430 2204 ▶ return if exists $map->{$qkey};
Branch: 1 branch
BranchTrueFalseTotal
if exists $map->{$qkey} 29 2175 2204
431 2175 $map->{$qkey} = $class_path;
432 }
433  
434 # Merge external resource maps into this instance
435 # Accepts: class names, objects with resource_map(), or plain hashrefs
436 229 ▶sub add {
Subroutine add: called CC=6 SCAR=17.9
Pod documented
437 229 my ($self, @providers) = @_;
438 229 my $map = $self->resource_map;
439  
440 229 for my $provider (@providers) {
441 233 my $ext_map;
442 233 ▶ if (ref $provider eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $provider eq 'HASH') { } 48 185 233
443 48 $ext_map = $provider;
444 } else {
445 185 ▶ my $obj = ref $provider ? $provider : do {
Branch: 1 branch
BranchTrueFalseTotal
ref $provider ? : 12 173 185
446 173 require_module($provider); $provider->new;
447 };
448 185 $ext_map = $obj->resource_map;
449 }
450  
451 233 for my $kind (keys %$ext_map) {
452 2693 my $class_path = $ext_map->{$kind};
453  
454 2693 ▶ if (exists $map->{$kind}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $map->{$kind}) { } 33 2660 2693
455 # COLLISION: short name already taken
456 # Ensure the original entry also has a domain-qualified key
457 33 _qualify_class_path($map, $kind, $map->{$kind});
458 # New entry: domain-qualified only (no short name)
459 33 _qualify_class_path($map, $kind, $class_path);
460 } else {
461 # No collision: register short name + domain-qualified
462 2660 $map->{$kind} = $class_path;
463 2660 _qualify_class_path($map, $kind, $class_path);
464 }
465 }
466 }
467 229 return $self;
468 }
469  
470  
471 29 ▶sub add_crd {
Subroutine add_crd: called CC=9 SCAR=22.4
Pod documented
472 29 my ($self, @inputs) = @_;
473 29 require IO::K8s::CRD;
474 29 my %opts;
475 29 ▶ if (@inputs > 1 && ref $inputs[-1] eq 'HASH' && !exists $inputs[-1]{kind}) {
Branch: 1 branch
BranchTrueFalseTotal
if (@inputs > 1 and ref $inputs[-1] eq "HASH" and not exists $inputs[-1]{"kind"}) 0 29 29
Condition66%4/6
@inputs > 1 and ref $inputs[-1] eq "HASH" and not exists $inputs[-1]{"kind"}
!ll&&!rl&&r
2810
@inputs > 1 and ref $inputs[-1] eq "HASH"
!ll&&!rl&&r
2801
MC/DC0%0/3
@inputs > 1 and ref $inputs[-1] eq "HASH" and not exists $inputs[-1]{"kind"}
@inputs > 1 ref $inputs[-1] eq "HASH" not exists $inputs[-1]{"kind"}
Truth table50%2/4
A and B and not(C)
A= @inputs > 1B= ref $inputs[-1] eq "HASH"C= not exists $inputs[-1]{"kind"}
ABCresult
0XX0
10X0
1100
1111
476 0 %opts = %{ pop @inputs };
477 }
478 29 my %registered;
479 29 for my $input (@inputs) {
480 30 for my $crd (@{ IO::K8s::CRD->load($input) }) {
481 24 my $classes = IO::K8s::CRD->generate($crd, $self->_autogen_namespace, %opts);
482 21 my $kind = $crd->{spec}{names}{kind};
483 21 my $storage = $classes->{storage};
484 21 my %map = map { ("$_/$kind" => '+' . $classes->{$_}) } grep { $_ ne 'storage' } keys %$classes;
485 21 $map{$kind} = '+' . $classes->{$storage};
486 21 $self->add(\%map);
487 # See the POD above: merge into an existing registration for this
488 # Kind (two CRDs from different groups sharing a bare Kind) rather
489 # than overwriting it -- 'storage' is left alone so it keeps the
490 # first registration's value.
491 21 ▶ if (my $reg = $registered{$kind}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $reg = $registered{$kind}) { } 1 20 21
492 1 ▶ $reg->{$_} = $classes->{$_} for grep { $_ ne 'storage' && !exists $reg->{$_} } keys %$classes;
Condition66%2/3
$_ ne 'storage' && !exists $reg->{$_}
!ll&&!rl&&r
102
MC/DC50%1/2
$_ ne 'storage' && !exists $reg->{$_}
$_ ne 'storage' !exists $reg->{$_}
Truth table66%2/3
A && not(B)
A= $_ ne 'storage'B= !exists $reg->{$_}
ABresult
0X0
100
111
493 } else {
494 20 $registered{$kind} = { %$classes };
495 }
496 }
497 }
498 21 return \%registered;
499 }
500  
501 # Expand short class name to full class path
502 # Supports:
503 # 'Pod' -> lookup in resource_map -> IO::K8s::Api::Core::V1::Pod
504 # 'Api::Core::V1::Pod' -> IO::K8s::Api::Core::V1::Pod
505 # 'IO::K8s::...' -> returned as-is
506 # '+MyApp::K8s::Resource' -> MyApp::K8s::Resource (+ prefix = full class name)
507 #
508 # Search order (versionless path; an explicitly supplied apiVersion takes the
509 # exact-GVK path above and never falls through to these):
510 # 1. '+Full::Class' / 'IO::K8s::...' - verbatim
511 # 2. resource_map, domain-qualified key then short name (via _resolve_mapped,
512 # which checks class_namespaces first)
513 # 3. User's class_namespaces
514 # 4. A loaded or loadable class of exactly that name -- multi-segment names
515 # only ('My::StaticWebSite'); a single-segment bare name is read as a
516 # Kubernetes Kind and skips this step (k35)
517 # 5. IO::K8s relative path
518 # 6. Auto-generate from openapi_spec (if available)
519 9973 ▶sub expand_class {
Subroutine expand_class: called CC=24 SCAR=31.8
Pod documented
520 9973 my $api_version_supplied = @_ >= 3;
521 9973 my ($self, $class, $api_version) = @_;
522  
523 # +FullClassName - strip + and use as-is
524 9973 ▶ return substr($class, 1) if $class =~ /^\+/;
Branch: 1 branch
BranchTrueFalseTotal
if $class =~ /^\+/ 125 9848 9973
525  
526 9848 ▶ my $map = ref($self) ? $self->resource_map : \%DEFAULT_RESOURCE_MAP;
Branch: 1 branch
BranchTrueFalseTotal
ref $self ? : 9759 89 9848
527  
528 # An explicitly supplied apiVersion is an exact GVK request, including
529 # undef or an empty string. It never falls through to a bare Kind or
530 # class-name fallback: a class that cannot confirm the requested version
531 # must not be substituted silently (k17). The one exception is the
532 # resource_map's own short-name key — a legitimate GVK source when the
533 # mapped class's api_version() matches the request (k31). AutoGen
534 # joins in only for an exact group/version match in the openapi_spec's
535 # x-kubernetes-group-version-kind metadata and fails closed otherwise
536 # (no silent fallback to another version).
537 9848 ▶ if ($api_version_supplied) {
Branch: 1 branch
BranchTrueFalseTotal
if ($api_version_supplied) 972 8876 9848
538 972 ▶ return undef unless defined $api_version;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $api_version 0 972 972
539 972 my $qualified = "$api_version/$class";
540 972 ▶ if (exists $map->{$qualified}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $map->{$qualified}) 873 99 972
541 873 return $self->_resolve_mapped($map->{$qualified}, $class);
542 }
543 # No qualified key: the short-name key is a GVK source when the
544 # mapped class itself confirms the requested version (k31).
545 # It has priority over AutoGen — the user explicitly registered it.
546 99 ▶ if (my $mapped_class = $self->_resolve_short_name_gvk($map, $class, $api_version)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $mapped_class = $self->_resolve_short_name_gvk($map, $class, $api_version)) 4 95 99
547 4 return $mapped_class;
548 }
549 95 ▶ if (ref($self) && $self->has_openapi_spec) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self and $self->has_openapi_spec) 67 28 95
Condition66%2/3
ref $self and $self->has_openapi_spec
!ll&&!rl&&r
02867
MC/DC50%1/2
ref $self and $self->has_openapi_spec
ref $self $self->has_openapi_spec
Truth table66%2/3
A and B
A= ref $selfB= $self->has_openapi_spec
ABresult
0X0
100
111
550 67 my $autogen = $self->_autogen_class_for($class, $api_version);
551 60 ▶ return $autogen if $autogen;
Branch: 1 branch
BranchTrueFalseTotal
if $autogen 57 3 60
552 }
553 31 return undef;
554 }
555  
556 # Already a full IO::K8s class name - return as-is
557 8876 ▶ return $class if $class =~ /^IO::K8s::/;
Branch: 1 branch
BranchTrueFalseTotal
if $class =~ /^IO::K8s::/ 7695 1181 8876
558  
559 # Domain-qualified string: 'cilium.io/v2/NetworkPolicy'
560 1181 ▶ if ($class =~ m{/}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($class =~ m[/]) 230 951 1181
561 230 ▶ if (exists $map->{$class}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $map->{$class}) 214 16 230
562 214 return $self->_resolve_mapped($map->{$class}, (split m{/}, $class)[-1]);
563 }
564 # k31: same short-name fallback, apiVersion taken from the string.
565 16 my ($av, $kind) = $class =~ m{\A(.*)/([^/]*)\z};
566 16 ▶ if (my $mapped_class = $self->_resolve_short_name_gvk($map, $kind, $av)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $mapped_class = $self->_resolve_short_name_gvk($map, $kind, $av)) 2 14 16
567 2 return $mapped_class;
568 }
569 14 return undef;
570 }
571  
572 # Short name like "Pod" - look up in resource_map
573 951 ▶ if (my $mapped = $map->{$class}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $mapped = $map->{$class}) 920 31 951
574 920 return $self->_resolve_mapped($mapped, $class);
575 }
576  
577 # Not in resource_map - might be a CRD or relative path
578 # 1. Check user's class_namespaces
579 31 ▶ if (ref($self)) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self) 30 1 31
580 30 for my $ns (@{$self->class_namespaces}) {
581 1 my $user_class = "${ns}::${class}";
582 1 ▶ return $user_class if _class_exists($user_class);
Branch: 1 branch
BranchTrueFalseTotal
if _class_exists($user_class) 1 0 1
583 }
584 }
585  
586 # 2. A MULTI-SEGMENT class name that is loaded, or loadable from @INC.
587 # This is the documented CRD case: a class named in full, e.g.
588 # 'My::StaticWebSite'. It has to load, not just test — _resolve_mapped()
589 # returns a '+'-prefixed resource_map value without loading it, and a
590 # consumer may name their class here before anything has pulled it in.
591 #
592 # Must stay *below* the resource_map lookup (k34, GH #7/#8). A bare
593 # Kind is a Kubernetes Kind first and a package name second: with this
594 # ahead of the map, smokers that had the CPAN distributions Event or Role
595 # installed got those back from expand_class('Event')/('Role') instead of
596 # IO::K8s::Api::Core::V1::Event / IO::K8s::Api::Rbac::V1::Role.
597 #
598 # Single-segment names are excluded outright (k35). Below the map
599 # they were only reachable for a Kind the model does not know, but that
600 # still shadowed AutoGen: with an openapi_spec defining kind 'Widget'
601 # and a top-level Widget.pm installed, expand_class('Widget') returned
602 # the foreign distribution instead of the generated class. A one-segment
603 # bare name carries no namespace to tell a Kind from a package, so it is
604 # read as a Kind: it goes on to IO::K8s::<Kind> and then to AutoGen.
605 # Multi-segment names are unambiguous and keep the probe.
606 #
607 # What used to force this check to also catch single-segment names was
608 # struct_to_object() re-expanding an already-resolved class. It no
609 # longer does — new_object()/json_to_object()/_inflate_struct() hand
610 # their resolved name to _struct_to_object_expanded() instead (k35),
611 # so a resource_map value of '+Widget', or new_object('+Widget'),
612 # never reaches expand_class() a second time.
613 #
614 # Escape hatches for a single-segment class of your own, all documented:
615 # '+Widget', class_namespaces, or a resource_map entry.
616 30 ▶ return $class if $class =~ /::/ && _class_exists($class);
Branch: 1 branch
BranchTrueFalseTotal
if $class =~ /::/ and _class_exists($class) 5 25 30
Condition100%3/3
$class =~ /::/ and _class_exists($class)
!ll&&!rl&&r
2145
MC/DC100%2/2
$class =~ /::/ and _class_exists($class)
$class =~ /::/ _class_exists($class)
Truth table100%3/3
A and B
A= $class =~ /::/B= _class_exists($class)
ABresult
0X0
100
111
617  
618 # 3. Check IO::K8s relative path
619 25 my $builtin_class = 'IO::K8s::' . $class;
620 25 ▶ return $builtin_class if _class_exists($builtin_class);
Branch: 1 branch
BranchTrueFalseTotal
if _class_exists($builtin_class) 4 21 25
621  
622 # 4. Try auto-generation for unknown types
623 21 ▶ if (ref($self) && $self->has_openapi_spec) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self and $self->has_openapi_spec) 12 9 21
Condition100%3/3
ref $self and $self->has_openapi_spec
!ll&&!rl&&r
1812
MC/DC100%2/2
ref $self and $self->has_openapi_spec
ref $self $self->has_openapi_spec
Truth table100%3/3
A and B
A= ref $selfB= $self->has_openapi_spec
ABresult
0X0
100
111
624 12 my $autogen = $self->_autogen_class_for($class);
625 10 ▶ return $autogen if $autogen;
Branch: 1 branch
BranchTrueFalseTotal
if $autogen 10 0 10
626 }
627  
628 # Fall back
629 9 return $builtin_class;
630 }
631  
632 # Turn a resource_map VALUE into an actual class name.
633 #
634 # Shared by all three lookup branches of expand_class() so that a hit on a
635 # domain-qualified key ('$api_version/$Kind') resolves exactly like a hit on
636 # the bare short name. It did not use to: the qualified branches built
637 # "IO::K8s::$mapped" directly and skipped the class_namespaces search, so a
638 # consumer with class_namespaces => ['My::K8s'] got their own subclass from
639 # expand_class('Pod') but the IO::K8s class from expand_class('Pod', 'v1') --
640 # and inflate() always passes the apiVersion. That branch was effectively
641 # dead while the built-in map had no qualified keys; adding them made it the
642 # normal path.
643 #
644 # $kind is only used for the openapi_spec autogen fallback.
645 2013 ▶sub _resolve_mapped {
Subroutine _resolve_mapped: called CC=9 SCAR=28.4
646 2013 my ($self, $mapped, $kind) = @_;
647  
648 # Mapped value with + prefix = full class name, used as-is (no
649 # class_namespaces lookup - the provider named an exact class).
650 2013 ▶ return substr($mapped, 1) if $mapped =~ /^\+/;
Branch: 1 branch
BranchTrueFalseTotal
if $mapped =~ /^\+/ 145 1868 2013
651  
652 # 1. Check user's class_namespaces first
653 1868 ▶ if (ref($self)) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self) 1780 88 1868
654 1780 for my $ns (@{$self->class_namespaces}) {
655 7 my $user_class = "${ns}::${mapped}";
656 7 ▶ return $user_class if _class_exists($user_class);
Branch: 1 branch
BranchTrueFalseTotal
if _class_exists($user_class) 7 0 7
657 }
658 }
659  
660 # 2. Check IO::K8s built-in
661 1861 my $builtin_class = 'IO::K8s::' . $mapped;
662 1861 ▶ return $builtin_class if _class_exists($builtin_class);
Branch: 1 branch
BranchTrueFalseTotal
if _class_exists($builtin_class) 1861 0 1861
663  
664 # 3. Try auto-generation if we have openapi_spec
665 0 ▶ if (ref($self) && $self->has_openapi_spec) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self and $self->has_openapi_spec) 0 0 0
Condition0%0/3
ref $self and $self->has_openapi_spec
!ll&&!rl&&r
000
MC/DC0%0/2
ref $self and $self->has_openapi_spec
ref $self $self->has_openapi_spec
Truth table0%0/3
A and B
A= ref $selfB= $self->has_openapi_spec
ABresult
0X0
100
111
666 0 my $autogen = $self->_autogen_class_for($kind);
667 0 ▶ return $autogen if $autogen;
Branch: 1 branch
BranchTrueFalseTotal
if $autogen 0 0 0
668 }
669  
670 # Fall back to IO::K8s:: path (might not exist, but let load_class handle error)
671 0 return $builtin_class;
672 }
673  
674 # k31: resolve a resource_map short-name key as a GVK source on the
675 # explicit-apiVersion path. The qualified '$api_version/$Kind' key is the
676 # primary lookup; this is the fallback for a map that only carries the
677 # short name (e.g. a CRD registered as 'StaticWebSite => "+My::StaticWebSite"').
678 #
679 # Fail closed: the mapped class must exist, expose api_version(), and report
680 # exactly the requested version — otherwise undef (k17 semantics: never
681 # substitute a class that cannot verify the request). No class is loaded
682 # unless the short-name key exists, and _class_exists short-circuits on
683 # $class->can('new'), so the common qualified-key hit costs nothing.
684 115 ▶sub _resolve_short_name_gvk {
Subroutine _resolve_short_name_gvk: called CC=8 SCAR=20.8
685 115 my ($self, $map, $kind, $api_version) = @_;
686  
687 115 ▶ return unless exists $map->{$kind};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $map->{$kind} 82 33 115
688 33 my $mapped = $map->{$kind};
689  
690 # Same full-class derivation as _qualify_class_path: a '+' prefix means
691 # the mapped value is already a full class name.
692 33 ▶ my $full_class = $mapped =~ /^\+/
Branch: 1 branch
BranchTrueFalseTotal
$mapped =~ /^\+/ ? : 11 22 33
693 ? substr($mapped, 1) : "IO::K8s::$mapped";
694  
695 33 ▶ return unless _class_exists($full_class) && $full_class->can('api_version');
Branch: 1 branch
BranchTrueFalseTotal
unless _class_exists($full_class) and $full_class->can("api_version") 1 32 33
Condition66%2/3
_class_exists($full_class) and $full_class->can("api_version")
!ll&&!rl&&r
0132
MC/DC50%1/2
_class_exists($full_class) and $full_class->can("api_version")
_class_exists($full_class) $full_class->can("api_version")
Truth table66%2/3
A and B
A= _class_exists($full_class)B= $full_class->can("api_version")
ABresult
0X0
100
111
696 # Ask as a class method, but only accept an answer that comes back without
697 # error (same guard as IO::K8s::List::api_version). A class registered via
698 # resource_map need not be an IO::K8s::APIObject: api_version may be an
699 # instance attribute (class-method call dies) or simply return undef. Both
700 # fail closed here rather than dying or warning.
701 32 my $class_api_version = eval { $full_class->api_version };
702 32 ▶ return if $@;
Branch: 1 branch
BranchTrueFalseTotal
if $@ 1 31 32
703 31 ▶ return unless defined $class_api_version && $class_api_version eq $api_version;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $class_api_version and $class_api_version eq $api_version 25 6 31
Condition100%3/3
defined $class_api_version and $class_api_version eq $api_version
!ll&&!rl&&r
1246
MC/DC100%2/2
defined $class_api_version and $class_api_version eq $api_version
defined $class_api_version $class_api_version eq $api_version
Truth table100%3/3
A and B
A= defined $class_api_versionB= $class_api_version eq $api_version
ABresult
0X0
100
111
704  
705 6 return $self->_resolve_mapped($mapped, $kind);
706 }
707  
708 # Check if a class exists (is loaded or can be loaded)
709 4144 ▶sub _class_exists {
Subroutine _class_exists: called CC=2 SCAR=6.9
710 4144 my ($class) = @_;
711 # Check if already loaded
712 4144 ▶ return 1 if $class->can('new');
Branch: 1 branch
BranchTrueFalseTotal
if $class->can("new") 3510 634 4144
713 # Try to load it
714 634 eval { require_module($class) };
715 634 return !$@;
716 }
717  
718 # Auto-generate a class from OpenAPI spec for unknown type
719 #
720 # $api_version is optional. When given, this is an exact GVK request: the
721 # definition must carry a matching x-kubernetes-group-version-kind entry
722 # (handled by _find_definition_for_kind) and the generated class gets that
723 # apiVersion. When omitted, the versionless compatibility fallback picks a
724 # deterministic default definition and version.
725 #
726 # The cache key is GVK-specific so the same definition requested under two
727 # apiVersions (a definition with several GVK entries) yields two classes.
728 79 ▶sub _autogen_class_for {
Subroutine _autogen_class_for: called CC=7 SCAR=19.5
729 79 my ($self, $kind, $api_version) = @_;
730  
731 79 ▶ return unless $self->has_openapi_spec;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->has_openapi_spec 0 79 79
732  
733 79 my $spec = $self->openapi_spec;
734 79 ▶ my $defs = $spec->{definitions} // {};
Condition50%1/2
$spec->{"definitions"} // {}
l!l
790
MC/DC0%0/1
$spec->{"definitions"} // {}
$spec->{"definitions"}
Truth table50%1/2
A
A= $spec->{"definitions"}
Aresult
11
00
735  
736 # Find the definition for this kind
737 79 my $def_name = $self->_find_definition_for_kind($kind, $api_version, $defs);
738 78 ▶ return unless $def_name;
Branch: 1 branch
BranchTrueFalseTotal
unless $def_name 3 75 78
739  
740 # Cache key is GVK-specific
741 75 my $cache_key = $self->_autogen_namespace . '::' . $def_name;
742 75 ▶ $cache_key .= "::$api_version" if defined $api_version;
Branch: 1 branch
BranchTrueFalseTotal
if defined $api_version 63 12 75
743 75 ▶ return $_autogen_cache{$cache_key} if $_autogen_cache{$cache_key};
Branch: 1 branch
BranchTrueFalseTotal
if $_autogen_cache{$cache_key} 43 32 75
744  
745 # Generate the class
746 32 my %autogen_opts;
747 32 ▶ $autogen_opts{api_version} = $api_version if defined $api_version;
Branch: 1 branch
BranchTrueFalseTotal
if defined $api_version 24 8 32
748 my $class = IO::K8s::AutoGen::get_or_generate(
749 $def_name,
750 32 $defs->{$def_name},
751 $defs,
752 $self->_autogen_namespace,
753 %autogen_opts,
754 );
755  
756 24 $_autogen_cache{$cache_key} = $class;
757 24 return $class;
758 }
759  
760 # Find OpenAPI definition name for a given kind.
761 #
762 # With an $api_version this is an EXACT GVK request: only definitions whose
763 # x-kubernetes-group-version-kind metadata carries that exact group/version
764 # count as candidates (a def_name suffix match cannot verify the version and
765 # is ignored). Exactly one candidate is returned; several are an ambiguity
766 # error (the defs are listed sorted, so the error is deterministic); none is
767 # undef (fail closed).
768 #
769 # Without an $api_version this is the deterministic versionless
770 # compatibility fallback: every def that matches the kind -- by GVK metadata
771 # or by def_name suffix -- is a candidate, and the lexicographically first
772 # def_name wins. Hash iteration order never influences the pick.
773 79 ▶sub _find_definition_for_kind {
Subroutine _find_definition_for_kind: called CC=11 SCAR=24.0
774 79 my ($self, $kind, $api_version, $defs) = @_;
775  
776 79 my %candidates;
777 79 for my $def_name (keys %$defs) {
778 310 my $def = $defs->{$def_name};
779 310 my $gvk_list = $def->{'x-kubernetes-group-version-kind'};
780  
781 310 ▶ if ($gvk_list) {
Branch: 1 branch
BranchTrueFalseTotal
if ($gvk_list) 169 141 310
782 169 for my $gvk (@$gvk_list) {
783 186 ▶ next unless $gvk->{kind} eq $kind;
Branch: 1 branch
BranchTrueFalseTotal
unless $gvk->{"kind"} eq $kind 80 106 186
784 106 ▶ if (defined $api_version) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $api_version) { } 89 17 106
785 89 my $av = _gvk_api_version($gvk);
786 89 ▶ $candidates{$def_name} = 1 if $av eq $api_version;
Branch: 1 branch
BranchTrueFalseTotal
if $av eq $api_version 65 24 89
787 } else {
788 17 $candidates{$def_name} = 1;
789 }
790 }
791 }
792  
793 # Versionless only: a def_name ending in the kind is a candidate too
794 310 ▶ if (!defined $api_version && $def_name =~ /\.\Q$kind\E$/) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $api_version and $def_name =~ /\.\Q$kind\E$/) 16 294 310
Condition100%3/3
not defined $api_version and $def_name =~ /\.\Q$kind\E$/
!ll&&!rl&&r
2791516
MC/DC100%2/2
not defined $api_version and $def_name =~ /\.\Q$kind\E$/
not defined $api_version $def_name =~ /\.\Q$kind\E$/
Truth table100%3/3
not(A) and B
A= not defined $api_versionB= $def_name =~ /\.\Q$kind\E$/
ABresult
0X0
100
111
795 16 $candidates{$def_name} = 1;
796 }
797 }
798  
799 79 my @candidates = sort keys %candidates;
800  
801 79 ▶ if (defined $api_version) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $api_version) 67 12 79
802 67 ▶ if (@candidates > 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (@candidates > 1) 1 66 67
803 1 croak "GVK ambiguity for kind '$kind', apiVersion '$api_version': "
804 . 'multiple definitions match ('
805 . join(', ', @candidates) . ')';
806 }
807 66 return $candidates[0];
808 }
809  
810 12 return $candidates[0];
811 }
812  
813 # Wire apiVersion a GVK entry represents: group/version, or bare version
814 # when the group is empty (core group).
815 89 ▶sub _gvk_api_version {
Subroutine _gvk_api_version: called CC=4 SCAR=14.9
816 89 my ($entry) = @_;
817 89 ▶ my $group = $entry->{group} // '';
Condition50%1/2
$entry->{"group"} // ""
l!l
890
MC/DC0%0/1
$entry->{"group"} // ""
$entry->{"group"}
Truth table50%1/2
A
A= $entry->{"group"}
Aresult
11
00
818 89 ▶ my $version = $entry->{version} // '';
Condition50%1/2
$entry->{"version"} // ""
l!l
890
MC/DC0%0/1
$entry->{"version"} // ""
$entry->{"version"}
Truth table50%1/2
A
A= $entry->{"version"}
Aresult
11
00
819 89 ▶ return $group ? "$group/$version" : $version;
Branch: 1 branch
BranchTrueFalseTotal
$group ? : 89 0 89
820 }
821  
822 91664 ▶sub load_class {
Subroutine load_class: called CC=3 SCAR=11.0
Pod documented
823 91664 my ($self, $class) = @_;
824  
825 # Memoised: this is called once per nested object on every inflate and
826 # once per hashref coercion into a named class, and require_module does
827 # real work every time -- validate the module name, rewrite '::' to '/',
828 # append '.pm', then require -- to reach a %INC hit that has been true
829 # since the first call. Measured at ~1.9us per call against ~0.05us for
830 # the lookup below, worth ~15% of a full inflate (k102 round).
831 #
832 # `defined` first: an undef $class must keep dying out of Module::Runtime
833 # with its own 'argument is not a module name' message (the k39 path),
834 # not warn about an uninitialized hash key on the way there.
835 91664 ▶ return 1 if defined $class && $_loaded_class{$class};
Branch: 1 branch
BranchTrueFalseTotal
if defined $class and $_loaded_class{$class} 87516 4148 91664
Condition100%3/3
defined $class and $_loaded_class{$class}
!ll&&!rl&&r
2414687516
MC/DC100%2/2
defined $class and $_loaded_class{$class}
defined $class $_loaded_class{$class}
Truth table100%3/3
A and B
A= defined $classB= $_loaded_class{$class}
ABresult
0X0
100
111
836 4148 require_module $class;
837 4135 $_loaded_class{$class} = 1;
838 4135 return 1;
839 }
840  
841 90 ▶sub json_to_object {
Subroutine json_to_object: called CC=2 SCAR=6.9
Pod documented
842 90 my ($self, $class_or_json, $json) = @_;
843 90 local $IO::K8s::Resource::STRICT = $self->strict;
844  
845 # If only one argument, auto-detect class from kind
846 90 ▶ if (!defined $json) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $json) 40 50 90
847 40 return $self->inflate($class_or_json);
848 }
849  
850 # Two arguments: class and JSON
851 50 my $class = $self->_expand_class_or_die($class_or_json);
852 49 my $struct = $self->json->decode($json);
853 49 return $self->_struct_to_object_expanded($class, $struct);
854 }
855  
856 7837 ▶sub struct_to_object {
Subroutine struct_to_object: called CC=3 SCAR=11.0
Pod documented
857 7837 my ($self, $class_or_struct, $params) = @_;
858 7837 local $IO::K8s::Resource::STRICT = $self->strict;
859  
860 # If only one argument (a hashref), auto-detect class from kind
861 7837 ▶ if (!defined $params && ref($class_or_struct) eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $params and ref $class_or_struct eq "HASH") 32 7805 7837
Condition66%2/3
not defined $params and ref $class_or_struct eq "HASH"
!ll&&!rl&&r
7805032
MC/DC50%1/2
not defined $params and ref $class_or_struct eq "HASH"
not defined $params ref $class_or_struct eq "HASH"
Truth table66%2/3
not(A) and B
A= not defined $paramsB= ref $class_or_struct eq "HASH"
ABresult
0X0
100
111
862 32 return $self->inflate($class_or_struct);
863 }
864  
865 # Two arguments: a class name that still needs resolving, plus params.
866 # This is the public entry point, so the name may be anything
867 # expand_class() accepts (a short Kind, a domain-qualified GVK string, a
868 # '+' full class). Callers that already hold a resolved class name must
869 # use _struct_to_object_expanded() instead — see k35.
870 7805 return $self->_struct_to_object_expanded(
871 $self->_expand_class_or_die($class_or_struct), $params);
872 }
873  
874 # struct_to_object() minus the name resolution: $class is already the final
875 # class name.
876 #
877 # Split out for k35. new_object()/json_to_object() used to call
878 # expand_class() and then hand the result to struct_to_object(), which
879 # expanded it a second time. That second pass re-entered the full search
880 # order, so an exactly-resolved name could be re-interpreted:
881 # new_object('+Secret', ...) resolved to 'Secret', and the re-expansion found
882 # 'Secret' in the resource_map and returned the core v1 Kind instead of the
883 # caller's class. It also forced expand_class()'s loadable-class probe to
884 # stay broad enough to catch already-resolved names, which is what kept the
885 # shadow window open.
886 #
887 # $where is optional and only ever read for an error message: _inflate_struct
888 # passes the parent class and field a nested value sits under, so a refused
889 # value can be found in the caller's manifest.
890 85481 ▶sub _struct_to_object_expanded {
Subroutine _struct_to_object_expanded: called CC=9 SCAR=22.0
891 85481 my ($self, $class, $params, $where) = @_;
892  
893 # Already an object of the right class — pass through as-is
894 85481 ▶ return $params if Scalar::Util::blessed($params) && $params->isa($class);
Branch: 1 branch
BranchTrueFalseTotal
if builtin::blessed($params) and $params->isa($class) 25 85456 85481
Condition100%3/3
builtin::blessed($params) and $params->isa($class)
!ll&&!rl&&r
8508736925
MC/DC100%2/2
builtin::blessed($params) and $params->isa($class)
builtin::blessed($params) $params->isa($class)
Truth table100%3/3
A and B
A= builtin::blessed($params)B= $params->isa($class)
ABresult
0X0
100
111
895  
896 85456 $self->load_class($class);
897  
898 # Self-inflating classes (union types like the apiextensions JSONSchemaProps*
899 # alternatives) take over completely: they serialize as a bare value, not as
900 # a hashref of attributes, so the generic path below would lose the data.
901 85452 ▶ return $class->FROM_STRUCT($params, $self) if $class->can('FROM_STRUCT');
Branch: 1 branch
BranchTrueFalseTotal
if $class->can("FROM_STRUCT") 10849 74603 85452
902  
903 # Every other class is built from a hash (a JSON object) and nothing
904 # else. A defined value of any other shape -- an array, a plain string,
905 # a CODE or SCALAR ref -- used to reach _inflate_struct's `return {}`
906 # fallback and come out as an empty object, so metadata => [] built a
907 # Pod with `metadata: {}` while Pod->new(metadata => []) failed its type
908 # check (k146). Refused here, after FROM_STRUCT, because the union
909 # classes above legitimately take arrays and booleans. Left alone on
910 # purpose: undef (no value, handled like an absent field). Independent
911 # of strict, which is about undeclared keys, not shape.
912 #
913 # A blessed value of another class is read through its TO_JSON and has
914 # to come out as a hash like anything else. Without a TO_JSON it is
915 # refused: a JSON boolean at `metadata` -- what "metadata": true
916 # decodes to -- used to fall through to the same `return {}` and build
917 # an empty ObjectMeta (k153). An IO::K8s object of a FOREIGN class stays
918 # accepted on purpose and is converted: AutoGen/CRD classes and core
919 # classes of the same shape get mixed in practice -- a core
920 # LabelSelector handed to a generated selector field -- and its
921 # undeclared fields are kept per D1 (dies under strict), exactly as if
922 # the caller had passed its TO_JSON hash.
923 74603 ▶ if (Scalar::Util::blessed($params)) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($params)) 28 74575 74603
924 28 ▶ $self->_refuse_object_shape($class, $self->_describe_shape($params), $where)
Branch: 1 branch
BranchTrueFalseTotal
unless $params->can("TO_JSON") 21 7 28
925 unless $params->can('TO_JSON');
926 7 my $data = $params->TO_JSON;
927 7 ▶ $self->_refuse_object_shape($class, $self->_describe_shape($params)
Branch: 1 branch
BranchTrueFalseTotal
unless ref $data eq "HASH" 3 4 7
928 .' whose TO_JSON returned '.$self->_describe_shape($data), $where)
929 unless ref $data eq 'HASH';
930 4 $params = $data;
931 }
932 74579 ▶ $self->_refuse_object_shape($class, $self->_describe_shape($params), $where)
Branch: 1 branch
BranchTrueFalseTotal
if defined $params and ref $params ne "HASH" 112 74467 74579
Condition66%2/3
defined $params and ref $params ne "HASH"
!ll&&!rl&&r
074467112
MC/DC50%1/2
defined $params and ref $params ne "HASH"
defined $params ref $params ne "HASH"
Truth table66%2/3
A and B
A= defined $paramsB= ref $params ne "HASH"
ABresult
0X0
100
111
933 if defined $params && ref $params ne 'HASH';
934  
935 74467 my $inflated = $self->_inflate_struct($class, $params);
936 74221 return $self->_construct($class, $inflated);
937 }
938  
939 # Builds an object of $class from its inflated arguments: the one place
940 # IO::K8s calls a constructor (k164).
941 #
942 # An error the constructor raises about those arguments blames the line
943 # that called it, which is the one below: Moo croaks "Missing required
944 # arguments" from the frame of the class being built, and a Type::Tiny
945 # exception takes the first frame outside Type::Tiny. Neither gets past
946 # IO::K8s by @CARP_NOT -- the classes being built are not ours to mark,
947 # and Type::Tiny does not read @CARP_NOT at all -- so _blame_caller moves
948 # such an error to the place a croak from here is reported.
949 74667 ▶sub _construct {
Subroutine _construct: called CC=2 SCAR=6.9
950 74667 my ($self, $class, $args) = @_;
951 74667 my $object;
952 74667 ▶ return $object if eval { $object = $class->new(%$args); 1 };
Branch: 1 branch
BranchTrueFalseTotal
if eval { do { $object = $class->new(%$args); 1 } } 74575 92 74667
953 92 my $error = $@;
954 92 die $self->_blame_caller($error);
955 }
956  
957 # $error moved to the place a croak from IO::K8s at this point is reported,
958 # when it blames a line of this file (k164) -- inside _construct, only the
959 # constructor's own complaint does. Carp decides the place, by the
960 # @CARP_NOT declarations of the distribution: the line that called into
961 # IO::K8s, the manifest line of a Kind call in a .pk8s (k163), the caller
962 # of add_crd or to_crd. A Type::Tiny exception stays the same object with
963 # its context moved; a string gets the new location in the form Carp
964 # writes it.
965 #
966 # Everything else is returned as it is: an error blaming another place (a
967 # class's own BUILD, a bug elsewhere keeps pointing at itself), a Carp
968 # answer that is itself a line of the distribution (a path whose modules do
969 # not trust each other yet -- moving the blame there would only trade one
970 # internal line for another), and a full backtrace under $Carp::Verbose.
971 92 ▶sub _blame_caller {
Subroutine _blame_caller: called CC=11 SCAR=28.4
972 92 my ($self, $error) = @_;
973 92 my $at_construct = qr/ at \Q${\ __FILE__}\E line \d+(?: thread \d+)?\.\n\z/;
974 92 ▶ if (Scalar::Util::blessed($error)) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($error)) 53 39 92
975 53 ▶ return $error unless $error->isa('Error::TypeTiny');
Branch: 1 branch
BranchTrueFalseTotal
unless $error->isa("Error::TypeTiny") 0 53 53
976 53 my $context = $error->context;
977 return $error unless ref $context eq 'HASH'
978 53 ▶ && defined $context->{file} && $context->{file} eq __FILE__;
Branch: 1 branch
BranchTrueFalseTotal
unless ref $context eq "HASH" and defined $context->{"file"} and $context->{"file"} eq __FILE__ 53 0 53
Condition33%2/6
ref $context eq "HASH" and defined $context->{"file"} and $context->{"file"} eq __FILE__
!ll&&!rl&&r
0530
ref $context eq "HASH" and defined $context->{"file"}
!ll&&!rl&&r
0053
MC/DC0%0/3
ref $context eq "HASH" and defined $context->{"file"} and $context->{"file"} eq __FILE__
ref $context eq "HASH" defined $context->{"file"} $context->{"file"} eq __FILE__
Truth table25%1/4
A and B and C
A= ref $context eq "HASH"B= defined $context->{"file"}C= $context->{"file"} eq __FILE__
ABCresult
0XX0
10X0
1100
1111
979 0 ▶ my @at = $self->_caller_location or return $error;
Branch: 1 branch
BranchTrueFalseTotal
my(@at) = $self->_caller_location or return $error 0 0 0
980 0 @$context{qw( package file line )} = @at;
981 0 return $error;
982 }
983 39 ▶ return $error if ref $error || !defined $error || $error !~ $at_construct;
Branch: 1 branch
BranchTrueFalseTotal
if ref $error or not defined $error or not $error =~ /$at_construct/ 18 21 39
Condition50%3/6
ref $error or not defined $error or not $error =~ /$at_construct/
l!l&&r!l&&!r
01821
ref $error or not defined $error
l!l&&r!l&&!r
0039
MC/DC33%1/3
ref $error or not defined $error or not $error =~ /$at_construct/
ref $error not defined $error not $error =~ /$at_construct/
Truth table50%2/4
A or not(B) or not(C)
A= ref $errorB= not defined $errorC= not $error =~ /$at_construct/
ABCresult
1XX1
01X1
0011
0000
984 21 ▶ my (undef, $file, $line) = $self->_caller_location or return $error;
Branch: 1 branch
BranchTrueFalseTotal
my(undef, $file, $line) = $self->_caller_location or return $error 19 2 21
985 19 $error =~ s/$at_construct/ at $file line $line.\n/;
986 19 return $error;
987 }
988  
989 # Package, file and line of the place Carp reports a croak from IO::K8s at
990 # this point (k164), or nothing when that is a line of the distribution or
991 # Carp answers with a full backtrace instead of one line. Carp names the
992 # file and line; the package is that of the frame calling from there.
993 21 ▶sub _caller_location {
Subroutine _caller_location: called CC=6 SCAR=18.7
994 21 my ($self) = @_;
995 21 ▶ my ($file, $line) = Carp::shortmess('') =~ /\A at (.+) line (\d+)(?: thread \d+)?\.\n\z/
Branch: 1 branch
BranchTrueFalseTotal
() = Carp::shortmess("") =~ /\A at (.+) line (\d+)(?: thread \d+)?\.\n\z/ or return 21 0 21
996 or return;
997 21 ▶ return if $self->_is_own_file($file);
Branch: 1 branch
BranchTrueFalseTotal
if $self->_is_own_file($file) 2 19 21
998 19 ▶ for (my $level = 1; my @frame = caller $level; $level++) {
Branch: 1 branch
BranchTrueFalseTotal
if (my(@frame) = caller $level) 121 0 121
999 121 ▶ return ($frame[0], $file, $line) if $frame[1] eq $file && $frame[2] == $line;
Branch: 1 branch
BranchTrueFalseTotal
if $frame[1] eq $file and $frame[2] == $line 19 102 121
Condition66%2/3
$frame[1] eq $file and $frame[2] == $line
!ll&&!rl&&r
102019
MC/DC50%1/2
$frame[1] eq $file and $frame[2] == $line
$frame[1] eq $file $frame[2] == $line
Truth table66%2/3
A and B
A= $frame[1] eq $fileB= $frame[2] == $line
ABresult
0X0
100
111
1000 }
1001 0 return;
1002 }
1003  
1004 # True for a file of this distribution: this one, or a module below the
1005 # IO/K8s/ directory next to it.
1006 21 ▶sub _is_own_file {
Subroutine _is_own_file: called CC=2 SCAR=7.0
1007 21 my ($self, $file) = @_;
1008 21 state $dir = do { (my $d = __FILE__) =~ s/\.pm\z/\//; $d };
1009 21 ▶ return $file eq __FILE__ || index($file, $dir) == 0;
Condition66%2/3
$file eq __FILE__ || index($file, $dir) == 0
l!l&&r!l&&!r
0219
MC/DC50%1/2
$file eq __FILE__ || index($file, $dir) == 0
$file eq __FILE__ index($file, $dir) == 0
Truth table66%2/3
A || B
A= $file eq __FILE__B= index($file, $dir) == 0
ABresult
1X1
011
000
1010 }
1011  
1012 # How a refused value is named in an inflation error (k146, k153, k154).
1013 451 ▶sub _describe_shape {
Subroutine _describe_shape: called CC=4 SCAR=13.9
1014 451 my ($self, $value) = @_;
1015 451 ▶ return !defined $value ? 'undef'
Branch: 3 branches
BranchTrueFalseTotal
!defined($value) ? : 6 445 451
builtin::blessed($value) ? : 86 359 445
ref $value ? : 215 144 359
1016 : Scalar::Util::blessed($value) ? 'an object of class '.ref($value)
1017 : ref $value ? 'a reference of type '.ref($value)
1018 : 'a plain scalar';
1019 }
1020  
1021 # The one wording for a value that cannot become an object of $class
1022 # (k146, k153). $where names the parent class and field of a nested value.
1023 # $class is undef for a whole document handed to inflate, whose class the
1024 # missing hash would have named through its kind (k161).
1025 209 ▶sub _refuse_object_shape {
Subroutine _refuse_object_shape: called CC=3 SCAR=11.0
1026 209 my ($self, $class, $got, $where) = @_;
1027 209 ▶ croak 'Cannot inflate'.(defined $class ? ' '.$class : '')
Branch: 2 branches
BranchTrueFalseTotal
defined $class ? : 167 42 209
defined $where ? : 125 84 209
1028 .': expected a hash (a JSON object), got '.$got
1029 .(defined $where ? ' while inflating '.$where : '');
1030 }
1031  
1032 721 ▶sub inflate {
Subroutine inflate: called CC=10 SCAR=23.0
Pod documented
1033 721 my ($self, $data) = @_;
1034 721 local $IO::K8s::Resource::STRICT = $self->strict;
1035  
1036 # A hashref is the document, a plain string is JSON text for one. What
1037 # the text decodes to has to be a hash as well (k161): inflate('[]')
1038 # used to die with Perl's own "Not a HASH reference", and an arrayref,
1039 # undef or an object handed over directly came back as a JSON parse
1040 # error about a "malformed JSON string" -- none naming what was wrong.
1041 721 ▶ my $struct = defined $data && !ref $data ? $self->json->decode($data) : $data;
Branch: 1 branch
BranchTrueFalseTotal
defined $data && !ref($data) ? : 268 453 721
Condition100%3/3
defined $data and not ref $data
!ll&&!rl&&r
3450268
MC/DC100%2/2
defined $data and not ref $data
defined $data not ref $data
Truth table100%3/3
A and not(B)
A= defined $dataB= not ref $data
ABresult
0X0
100
111
1042 721 ▶ $self->_refuse_object_shape(undef, $self->_describe_shape($struct))
Branch: 1 branch
BranchTrueFalseTotal
unless ref $struct eq "HASH" 42 679 721
1043 unless ref $struct eq 'HASH';
1044  
1045 # croak, not die (k175): the error names the line that called inflate.
1046 my $kind = $struct->{kind}
1047 679 ▶ or croak "Cannot inflate: missing 'kind' field in data";
Branch: 1 branch
BranchTrueFalseTotal
my $kind = $struct->{"kind"} or croak("Cannot inflate: missing 'kind' field in data") 676 3 679
1048  
1049 # A List-shaped Kind ('List' itself, or any '...List') routes to the
1050 # generic IO::K8s::List container rather than expand_class(): the
1051 # per-Kind *List classes were removed in 1.105 in favour of it, so no
1052 # resource_map entry -- qualified or bare -- will ever resolve one, and
1053 # it owns its own inflation (deriving item types from its own
1054 # kind/apiVersion; see IO::K8s::List::FROM_STRUCT, k46).
1055 676 ▶ if ($kind =~ /List\z/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($kind =~ /List\z/) 153 523 676
1056 153 require IO::K8s::List;
1057 153 return IO::K8s::List->FROM_STRUCT($struct, $self);
1058 }
1059  
1060 523 my $api_version_supplied = exists $struct->{apiVersion};
1061 523 my $api_version = $struct->{apiVersion};
1062  
1063 523 ▶ my $class = $api_version_supplied
Branch: 1 branch
BranchTrueFalseTotal
$api_version_supplied ? : 519 4 523
1064 ? $self->expand_class($kind, $api_version)
1065 : $self->_expand_class_or_die($kind);
1066 516 ▶ if ($api_version_supplied && !defined $class) {
Branch: 1 branch
BranchTrueFalseTotal
if ($api_version_supplied and not defined $class) 11 505 516
Condition100%3/3
$api_version_supplied and not defined $class
!ll&&!rl&&r
350211
MC/DC100%2/2
$api_version_supplied and not defined $class
$api_version_supplied not defined $class
Truth table100%3/3
A and not(B)
A= $api_version_suppliedB= not defined $class
ABresult
0X0
100
111
1067 11 ▶ return $self->_unstructured_from_struct($struct)
Branch: 1 branch
BranchTrueFalseTotal
if $self->unknown_kinds eq "unstructured" 3 8 11
1068 if $self->unknown_kinds eq 'unstructured';
1069 8 _die_resolution_error($kind, $api_version);
1070 }
1071 505 $self->load_class($class);
1072 504 my $inflated = $self->_inflate_struct($class, $struct);
1073 446 return $self->_construct($class, $inflated);
1074 }
1075  
1076 530 ▶sub new_object {
Subroutine new_object: called CC=23 SCAR=32.9
Pod documented
1077 530 my ($self, $short_class, @args) = @_;
1078 530 local $IO::K8s::Resource::STRICT = $self->strict;
1079  
1080 # Support:
1081 # ->new_object('Pod', { ... })
1082 # ->new_object('Pod', foo => 'bar')
1083 # ->new_object('Pod', { ... }, 'cilium.io/v2') # with api_version
1084 530 my ($params, $api_version);
1085 530 my $api_version_supplied = 0;
1086 530 ▶ if (@args >= 2 && ref($args[0]) eq 'HASH' && !ref($args[1])) {
Branch: 2 branches
BranchTrueFalseTotal
if (@args >= 2 and ref $args[0] eq 'HASH' and not ref $args[1]) { } 14 516 530
elsif (@args == 1 and ref $args[0] eq 'HASH') { } 211 305 516
Condition83%5/6
@args >= 2 and ref $args[0] eq "HASH" and not ref $args[1]
!ll&&!rl&&r
516014
@args >= 2 and ref $args[0] eq "HASH"
!ll&&!rl&&r
21230414
MC/DC66%2/3
@args >= 2 and ref $args[0] eq "HASH" and not ref $args[1]
@args >= 2 ref $args[0] eq "HASH" not ref $args[1]
Truth table75%3/4
A and B and not(C)
A= @args >= 2B= ref $args[0] eq "HASH"C= not ref $args[1]
ABCresult
0XX0
10X0
1100
1111
1087 14 ($params, $api_version) = @args;
1088 14 $api_version_supplied = 1;
1089 ▶ } elsif (@args == 1 && ref($args[0]) eq 'HASH') {
Condition66%2/3
@args == 1 and ref $args[0] eq "HASH"
!ll&&!rl&&r
3050211
MC/DC50%1/2
@args == 1 and ref $args[0] eq "HASH"
@args == 1 ref $args[0] eq "HASH"
Truth table66%2/3
A and B
A= @args == 1B= ref $args[0] eq "HASH"
ABresult
0X0
100
111
1090 211 $params = $args[0];
1091 } else {
1092 305 $params = { @args };
1093 }
1094  
1095 # An apiVersion inside the params hash is an exact-GVK request too -- the
1096 # same key inflate() reads and honours. new_object used to ignore it and
1097 # resolve the short name to whatever version it defaults to, silently
1098 # substituting a version the caller did not ask for (k62). Honour it
1099 # for symmetry with inflate; when an explicit positional api_version is
1100 # also given the two must agree, or it is a genuine conflict and we fail
1101 # closed rather than pick one (the house line of k37/k39).
1102 530 ▶ if (ref($params) eq 'HASH' && exists $params->{apiVersion}) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $params eq "HASH" and exists $params->{"apiVersion"}) 16 514 530
Condition66%2/3
ref $params eq "HASH" and exists $params->{"apiVersion"}
!ll&&!rl&&r
051416
MC/DC50%1/2
ref $params eq "HASH" and exists $params->{"apiVersion"}
ref $params eq "HASH" exists $params->{"apiVersion"}
Truth table66%2/3
A and B
A= ref $params eq "HASH"B= exists $params->{"apiVersion"}
ABresult
0X0
100
111
1103 16 my $inner = $params->{apiVersion};
1104 16 ▶ if ($api_version_supplied) {
Branch: 1 branch
BranchTrueFalseTotal
if ($api_version_supplied) { } 2 14 16
1105 2 ▶ croak "new_object: conflicting apiVersion for kind '$short_class' -- "
Branch: 3 branches
BranchTrueFalseTotal
if defined $inner xor defined $api_version or defined $inner and defined $api_version and $inner ne $api_version 1 1 2
defined $inner ? : 1 0 1
defined $api_version ? : 1 0 1
Condition46%6/13
defined $inner xor defined $api_version or defined $inner and defined $api_version and $inner ne $api_version
l!l&&r!l&&!r
011
defined $inner xor defined $api_version
l&&rl&&!r!l&&r!l&&!r
2000
defined $inner and defined $api_version and $inner ne $api_version
!ll&&!rl&&r
011
defined $inner and defined $api_version
!ll&&!rl&&r
002
MC/DC20%1/5
defined $inner xor defined $api_version or defined $inner and defined $api_version and $inner ne $api_version
defined $inner defined $api_version defined $inner defined $api_version $inner ne $api_version
Truth table20%2/10
A xor B or C and D and E
A= defined $innerB= defined $api_versionC= defined $innerD= defined $api_versionE= $inner ne $api_version
ABCDEresult
10XXX1
01XXX1
111111
001111
110XX0
1110X0
111100
000XX0
0010X0
001100
1106 . "params hash says '" . (defined $inner ? $inner : '<undef>')
1107 . "', positional argument says '"
1108 . (defined $api_version ? $api_version : '<undef>') . "'"
1109 if (defined $inner xor defined $api_version)
1110 || (defined $inner && defined $api_version && $inner ne $api_version);
1111 } else {
1112 14 $api_version = $inner;
1113 14 $api_version_supplied = 1;
1114 }
1115 }
1116  
1117 529 ▶ my $class = $api_version_supplied
Branch: 1 branch
BranchTrueFalseTotal
$api_version_supplied ? : 27 502 529
1118 ? $self->expand_class($short_class, $api_version)
1119 : $self->_expand_class_or_die($short_class);
1120 523 ▶ if ($api_version_supplied && !defined $class) {
Branch: 1 branch
BranchTrueFalseTotal
if ($api_version_supplied and not defined $class) 7 516 523
Condition100%3/3
$api_version_supplied and not defined $class
!ll&&!rl&&r
496207
MC/DC100%2/2
$api_version_supplied and not defined $class
$api_version_supplied not defined $class
Truth table100%3/3
A and not(B)
A= $api_version_suppliedB= not defined $class
ABresult
0X0
100
111
1121 7 ▶ if ($self->unknown_kinds eq 'unstructured') {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->unknown_kinds eq "unstructured") 2 5 7
1122 2 ▶ my %struct = (ref($params) eq 'HASH') ? %$params : ();
Branch: 1 branch
BranchTrueFalseTotal
ref $params eq 'HASH' ? : 2 0 2
1123 2 ▶ $struct{kind} = $short_class unless exists $struct{kind};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $struct{"kind"} 2 0 2
1124 2 ▶ $struct{apiVersion} = $api_version unless exists $struct{apiVersion};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $struct{"apiVersion"} 2 0 2
1125 2 return $self->_unstructured_from_struct(\%struct);
1126 }
1127 5 _die_resolution_error($short_class, $api_version);
1128 }
1129 516 return $self->_struct_to_object_expanded($class, $params);
1130 }
1131  
1132 # unknown_kinds => 'unstructured' opt-in (D4): build an untyped
1133 # IO::K8s::Unstructured envelope from a document instead of dying, called
1134 # only from the two GVK-resolution-failure sites above -- inflate()'s
1135 # apiVersion-supplied branch and new_object()'s equivalent. apiVersion/kind
1136 # land on their own typed attributes; everything else preserved through
1137 # FROM_HASH's normal D1 handling (an undeclared constructor key is kept in
1138 # _unknown_fields and re-emitted by TO_JSON).
1139 #
1140 # strict => 1 is deliberately exempted here: inflate/new_object localize
1141 # $IO::K8s::Resource::STRICT for the whole call, but Unstructured never
1142 # declares spec/status/etc, so every field beyond apiVersion/kind/metadata
1143 # would trip strict on the one class whose entire purpose is preserving
1144 # them. The exemption is scoped to this fallback alone -- a registered
1145 # Kind (a Pod with a bogus field, say) still dies under strict, since this
1146 # sub is only ever reached once resolution has already failed.
1147 5 ▶sub _unstructured_from_struct {
Subroutine _unstructured_from_struct: called CC=1 SCAR=0.0
1148 5 my ($self, $struct) = @_;
1149 5 local $IO::K8s::Resource::STRICT = 0;
1150 5 return IO::K8s::Unstructured->FROM_HASH($struct);
1151 }
1152  
1153 # expand_class() for a caller-supplied name that carries no separate
1154 # $api_version argument, failing closed the way the explicit-apiVersion path
1155 # already does.
1156 #
1157 # A name with its apiVersion inside the string ('cilium.io/v2/UnknownKind') is
1158 # an exact GVK request just like a separate argument, so an unresolvable one
1159 # comes back undef. That undef must become the GVK error here: passed on, it
1160 # reaches load_class() and dies out of Module::Runtime with 'argument is not a
1161 # module name', which names neither the kind nor the apiVersion (k39).
1162 #
1163 # A name WITHOUT a domain qualifier is not an undef case and must not become
1164 # one: expand_class() falls back to IO::K8s::<Name> there, so an unknown bare
1165 # Kind keeps failing on the missing module, not on GVK resolution.
1166 8361 ▶sub _expand_class_or_die {
Subroutine _expand_class_or_die: called CC=3 SCAR=11.0
1167 8361 my ($self, $name) = @_;
1168 8361 my $class = $self->expand_class($name);
1169 8360 ▶ if (!defined($class) && $name =~ m{\A(.*)/([^/]*)\z}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $class and $name =~ m[\A(.*)/([^/]*)\z]) 8 8352 8360
Condition66%2/3
not defined $class and $name =~ m[\A(.*)/([^/]*)\z]
!ll&&!rl&&r
835208
MC/DC50%1/2
not defined $class and $name =~ m[\A(.*)/([^/]*)\z]
not defined $class $name =~ m[\A(.*)/([^/]*)\z]
Truth table66%2/3
not(A) and B
A= not defined $classB= $name =~ m[\A(.*)/([^/]*)\z]
ABresult
0X0
100
111
1170 8 _die_resolution_error($2, $1);
1171 }
1172 8352 return $class;
1173 }
1174  
1175 21 ▶sub _die_resolution_error {
Subroutine _die_resolution_error: called CC=3 SCAR=11.1
1176 21 my ($kind, $api_version) = @_;
1177 21 ▶ my $display = !defined($api_version) ? '<undef>'
Branch: 2 branches
BranchTrueFalseTotal
!defined($api_version) ? : 0 21 21
length $api_version ? : 18 3 21
1178 : length($api_version) ? $api_version
1179 : '<empty>';
1180 21 die "Cannot resolve Kubernetes GVK: kind '$kind', apiVersion '$display'\n";
1181 }
1182  
1183 74971 ▶sub _inflate_struct {
Subroutine _inflate_struct: called CC=22 SCAR=31.1
1184 74971 my ($self, $class, $params) = @_;
1185  
1186 # Both callers hand over a plain hash or undef: inflate() only ever has
1187 # a decoded JSON object here, and _struct_to_object_expanded has already
1188 # turned a blessed value into its TO_JSON hash or refused it (k153) and
1189 # refused every other shape (k146). undef means "no value" and builds
1190 # an object with nothing set.
1191 74971 ▶ return {} unless ref $params eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $params eq "HASH" 0 74971 74971
1192  
1193 # Opaque fields that should be passed through as-is (complex JSON structures)
1194 74971 my %opaque_fields = map { $_ => 1 } qw(fieldsV1 rawExtension raw);
1195  
1196 # Get attribute info from the registry (keyed by Perl attr name)
1197 74971 my $attr_info = $class->_k8s_attr_info;
1198  
1199 # Build reverse map: JSON key → Perl attr name (for sanitized names)
1200 74971 my %json_to_perl;
1201 74971 for my $perl_name (keys %$attr_info) {
1202 2116137 ▶ my $json_key = $attr_info->{$perl_name}{json_key} // $perl_name;
Condition66%2/3
$attr_info->{$perl_name}{"json_key"} // $perl_name
l!l&&r!l&&!r
39852517176120
MC/DC0%0/2
$attr_info->{$perl_name}{"json_key"} // $perl_name
$attr_info->{$perl_name}{"json_key"} $perl_name
Truth table66%2/3
A // B
A= $attr_info->{$perl_name}{"json_key"}B= $perl_name
ABresult
1X1
011
000
1203 2116137 $json_to_perl{$json_key} = $perl_name;
1204 }
1205  
1206 74971 my %args;
1207  
1208 74971 for my $attr (keys %$params) {
1209 168089 my $value = $params->{$attr};
1210 168089 ▶ unless (defined $value) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $value) 105 167984 168089
1211 # A JSON null is "no value" and dropped -- except for a field
1212 # declared nullable, where it is a value of its own that TO_JSON
1213 # writes back (k158): the attribute is built with undef, so it
1214 # exists and has_<accessor> is true.
1215 105 ▶ my $opts = $attr_info->{ $json_to_perl{$attr} // $attr };
Condition33%1/3
$json_to_perl{$attr} // $attr
l!l&&r!l&&!r
10500
MC/DC0%0/2
$json_to_perl{$attr} // $attr
$json_to_perl{$attr} $attr
Truth table33%1/3
A // B
A= $json_to_perl{$attr}B= $attr
ABresult
1X1
011
000
1216 105 ▶ $opts = $opts->{options} if $opts;
Branch: 1 branch
BranchTrueFalseTotal
if $opts 105 0 105
1217 105 ▶ $args{$attr} = undef if $opts && $opts->{nullable};
Branch: 1 branch
BranchTrueFalseTotal
if $opts and $opts->{"nullable"} 60 45 105
Condition66%2/3
$opts and $opts->{"nullable"}
!ll&&!rl&&r
45060
MC/DC50%1/2
$opts and $opts->{"nullable"}
$opts $opts->{"nullable"}
Truth table66%2/3
A and B
A= $optsB= $opts->{"nullable"}
ABresult
0X0
100
111
1218 105 next;
1219 }
1220  
1221 # Pass through opaque fields without type coercion -- but not as the
1222 # caller's own reference (k54), see the else branch below.
1223 167984 ▶ if ($opaque_fields{$attr}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opaque_fields{$attr}) 503 167481 167984
1224 503 $args{$attr} = _shallow_copy($value);
1225 503 next;
1226 }
1227  
1228 # Look up by Perl attr name (handles sanitized JSON keys like x-kubernetes-*)
1229 167481 ▶ my $perl_name = $json_to_perl{$attr} // $attr;
Condition66%2/3
$json_to_perl{$attr} // $attr
l!l&&r!l&&!r
16535321280
MC/DC0%0/2
$json_to_perl{$attr} // $attr
$json_to_perl{$attr} $attr
Truth table66%2/3
A // B
A= $json_to_perl{$attr}B= $attr
ABresult
1X1
011
000
1230 167481 ▶ my $info = $attr_info->{$perl_name} // {};
Condition100%2/2
$attr_info->{$perl_name} // {}
l!l
1653532128
MC/DC100%1/1
$attr_info->{$perl_name} // {}
$attr_info->{$perl_name}
Truth table100%2/2
A
A= $attr_info->{$perl_name}
Aresult
11
00
1231  
1232 # An array field takes an array and a hash field a hash, whatever
1233 # its elements are (k154). The object branches below used to
1234 # dereference without looking, so containers => 'x' died with
1235 # Perl's own "Can't use string as an ARRAY ref", naming neither the
1236 # class nor the field; a scalar container reached the constructor
1237 # and got a Type::Tiny message without the class. Only the
1238 # container is checked -- the field's own isa already demanded it
1239 # (ArrayRef[...], HashRef[...], the bare HashRef of Opaque and of
1240 # the lenient { Str => 1 }), so nothing is refused that used to
1241 # pass, and the contents of an opaque map stay as unconstrained as
1242 # before.
1243 167481 ▶ if (my $shape = $self->_container_shape($info)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $shape = $self->_container_shape($info)) 31427 136054 167481
1244 31427 ▶ $self->_refuse_container_shape($class, $attr, $shape, $info->{class}, $value)
Branch: 1 branch
BranchTrueFalseTotal
unless ref $value eq $shape 71 31356 31427
1245 unless ref $value eq $shape;
1246 }
1247  
1248 # The registry's {class} is always a final class name: the k8s DSL
1249 # runs every declared type through IO::K8s::Resource::_expand_class
1250 # before storing it, and generated inline structs are named in full.
1251 # So these go straight to the pre-expanded path — sending them back
1252 # through expand_class() would re-interpret a name that is already
1253 # resolved (k35).
1254 #
1255 # The third argument names where a nested value sits, for the shape
1256 # error _struct_to_object_expanded raises (k146) -- worded like the
1257 # Bool message below and the element/key suffixes of the object
1258 # coercers in IO::K8s::Resource.
1259 167410 ▶ if ($info->{is_array_of_objects}) {
Branch: 5 branches
BranchTrueFalseTotal
if ($info->{'is_array_of_objects'}) { } 6703 160707 167410
elsif ($info->{'is_hash_of_objects'}) { } 10555 150152 160707
elsif ($info->{'is_hash_of_object_arrays'}) { } 153 149999 150152
elsif ($info->{'is_object'}) { } 22987 127012 149999
elsif ($info->{'is_bool'}) { } 7972 119040 127012
1260 6703 my $inner_class = $info->{class};
1261 $args{$attr} = [ map {
1262 6703 $self->_struct_to_object_expanded($inner_class, $value->[$_],
1263 $class.' field '.$attr.' at element '.$_)
1264 } 0 .. $#$value ];
1265 } elsif ($info->{is_hash_of_objects}) {
1266 10555 my $inner_class = $info->{class};
1267 $args{$attr} = { map {
1268 10555 $_ => $self->_struct_to_object_expanded($inner_class, $value->{$_},
1269 $class.' field '.$attr." at key '".$_."'")
1270 } keys %$value };
1271 } elsif ($info->{is_hash_of_object_arrays}) {
1272 153 my $inner_class = $info->{class};
1273 $args{$attr} = { map {
1274 153 my $key = $_;
1275 153 my $list = $value->{$key};
1276 $key => (ref $list eq 'ARRAY'
1277 ? [ map {
1278 153 ▶ $self->_struct_to_object_expanded($inner_class, $list->[$_],
Branch: 1 branch
BranchTrueFalseTotal
ref $list eq 'ARRAY' ? : 153 0 153
1279 $class.' field '.$attr." at key '".$key."' element ".$_)
1280 } 0 .. $#$list ]
1281 : $list)
1282 } keys %$value };
1283 } elsif ($info->{is_object}) {
1284 22987 $args{$attr} = $self->_struct_to_object_expanded($info->{class}, $value,
1285 $class.' field '.$attr);
1286 } elsif ($info->{is_bool}) {
1287 # Same normalization the Bool coercer in IO::K8s::Resource applies.
1288 # It has to be the same one: this runs before $class->new(%args),
1289 # so whatever it decides is all the coercer ever gets to see, and
1290 # a wrong answer here cannot be rescued downstream (k37).
1291 # On bad data it dies without naming the field; the constructor
1292 # path gets that context for free from Moo's coercion wrapper,
1293 # this path has to attach it itself (k42). $attr is the JSON
1294 # key -- the name that appears in the caller's manifest.
1295 7972 $args{$attr} = eval { IO::K8s::Resource::_normalize_bool($value) };
1296 7972 ▶ if (my $err = $@) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $err = $@) 6 7966 7972
1297 6 $err =~ s/\n\z//;
1298 6 die "$err while inflating $class field $attr\n";
1299 }
1300 } else {
1301 # Arrays of scalars, hashes of scalars and anything untyped: the
1302 # inflated object must not share the caller's containers, or later
1303 # edits to the source struct silently rewrite the object (k54).
1304 # One level only, matching the output side in
1305 # IO::K8s::Role::Resource::TO_JSON: a nested structure under an
1306 # opaque hash attribute (fieldsV1, a free-form HashRef) still
1307 # shares its inner refs with the struct it was inflated from.
1308 119040 $args{$attr} = _shallow_copy($value);
1309 }
1310 }
1311  
1312 74667 return \%args;
1313 }
1314  
1315 # One level of copying for a plain container, deliberately not deeper -- see
1316 # the callers above (k54). Anything that is not a plain ARRAY or HASH
1317 # (a scalar, a blessed value, a JSON boolean object) is returned untouched.
1318 119543 ▶sub _shallow_copy {
Subroutine _shallow_copy: called CC=3 SCAR=11.0
1319 119543 my ($value) = @_;
1320 119543 ▶ return [ @$value ] if ref $value eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "ARRAY" 10325 109218 119543
1321 109218 ▶ return { %$value } if ref $value eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "HASH" 4137 105081 109218
1322 105081 return $value;
1323 }
1324  
1325 # The container a registry entry's field holds -- 'ARRAY', 'HASH', or
1326 # nothing for a scalar or single-object field (k154). Read off the flag
1327 # prefix, the way IO::K8s::AutoGen::_element_compatible does, so a
1328 # container form the DSL gains later is covered without a list to keep in
1329 # step with IO::K8s::Resource. The free map (Opaque / HashRef, k191) is the
1330 # one hash form without an is_hash_of_ prefix.
1331 167481 ▶sub _container_shape {
Subroutine _container_shape: called CC=6 SCAR=17.9
1332 167481 my ($self, $info) = @_;
1333 167481 for my $flag (keys %$info) {
1334 235636 ▶ next unless $info->{$flag};
Branch: 1 branch
BranchTrueFalseTotal
unless $info->{$flag} 0 235636 235636
1335 235636 ▶ return 'ARRAY' if index($flag, 'is_array_of_') == 0;
Branch: 1 branch
BranchTrueFalseTotal
if index($flag, "is_array_of_") == 0 17071 218565 235636
1336 218565 ▶ return 'HASH' if index($flag, 'is_hash_of_') == 0 || $flag eq 'is_hash_opaque';
Branch: 1 branch
BranchTrueFalseTotal
if index($flag, "is_hash_of_") == 0 or $flag eq "is_hash_opaque" 14356 204209 218565
Condition100%3/3
index($flag, "is_hash_of_") == 0 or $flag eq "is_hash_opaque"
l!l&&r!l&&!r
14189167204209
MC/DC100%2/2
index($flag, "is_hash_of_") == 0 or $flag eq "is_hash_opaque"
index($flag, "is_hash_of_") == 0 $flag eq "is_hash_opaque"
Truth table100%3/3
A or B
A= index($flag, "is_hash_of_") == 0B= $flag eq "is_hash_opaque"
ABresult
1X1
011
000
1337 }
1338 136054 return;
1339 }
1340  
1341 # The same form for an array or hash field holding the wrong container
1342 # (k154): the class being inflated, the field, the expected container and,
1343 # for an array or hash of objects, the element class.
1344 186 ▶sub _refuse_container_shape {
Subroutine _refuse_container_shape: called CC=3 SCAR=11.0
1345 186 my ($self, $class, $attr, $shape, $of, $value) = @_;
1346 186 ▶ croak 'Cannot inflate '.$class.' field '.$attr.': expected '
Branch: 2 branches
BranchTrueFalseTotal
$shape eq 'ARRAY' ? : 161 25 186
defined $of ? : 159 27 186
1347 .($shape eq 'ARRAY' ? 'an array (a JSON array)' : 'a hash (a JSON object)')
1348 .(defined $of ? ' of '.$of : '')
1349 .', got '.$self->_describe_shape($value);
1350 }
1351  
1352 57 ▶sub object_to_struct {
Subroutine object_to_struct: called CC=1 SCAR=0.0
Pod documented
1353 57 my ($self, $object) = @_;
1354 57 return $object->TO_JSON;
1355 }
1356  
1357 134 ▶sub object_to_json {
Subroutine object_to_json: called CC=1 SCAR=0.0
Pod documented
1358 134 my ($self, $object) = @_;
1359 134 return $object->to_json;
1360 }
1361  
1362 54 ▶sub load {
Subroutine load: called CC=4 SCAR=13.9
Pod documented
1363 54 my ($self, $file, %opts) = @_;
1364  
1365 # vars (k160) is the one option; anything else is a typo that would
1366 # otherwise leave every var() in the manifest on its default.
1367 54 my $vars = delete $opts{vars};
1368 54 ▶ croak 'load: unknown option '.join(', ', map { "'".$_."'" } sort keys %opts)
Branch: 1 branch
BranchTrueFalseTotal
if %opts 1 53 54
1369 if %opts;
1370 53 ▶ croak 'load: vars must be a hash reference'
Branch: 1 branch
BranchTrueFalseTotal
if defined $vars and ref $vars ne "HASH" 1 52 53
Condition100%3/3
defined $vars and ref $vars ne "HASH"
!ll&&!rl&&r
4751
MC/DC100%2/2
defined $vars and ref $vars ne "HASH"
defined $vars ref $vars ne "HASH"
Truth table100%3/3
A and B
A= defined $varsB= ref $vars ne "HASH"
ABresult
0X0
100
111
1371 if defined $vars && ref $vars ne 'HASH';
1372  
1373 52 require IO::K8s::Manifest;
1374  
1375 # Set k8s instance for DSL functions
1376 52 local $IO::K8s::Manifest::_k8s_instance = $self;
1377  
1378 52 return IO::K8s::Manifest->_load_file($file, $self, $vars);
1379 }
1380  
1381 68 ▶sub load_yaml {
Subroutine load_yaml: called CC=10 SCAR=23.0
Pod documented
1382 68 my ($self, $file_or_string, %opts) = @_;
1383  
1384 # A file or YAML text, multi-document, by the rule IO::K8s::CRD->load
1385 # shares (k159, k162), with plain scalars resolved the kubectl way (k198).
1386 68 my ($refused, @docs) = $self->_yaml_documents($file_or_string, $self->_yaml_parser);
1387 68 ▶ croak "load_yaml: '".$file_or_string."' ".$refused if defined $refused;
Branch: 1 branch
BranchTrueFalseTotal
if defined $refused 4 64 68
1388  
1389 64 my $collect_errors = $opts{collect_errors};
1390 64 my @objects;
1391 my @errors;
1392  
1393 # Inflate each document - this validates types!
1394 64 for my $i (0 .. $#docs) {
1395 68 my $doc = $docs[$i];
1396 68 ▶ next unless $doc && ref($doc) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
unless $doc and ref $doc eq "HASH" 3 65 68
Condition100%3/3
$doc and ref $doc eq "HASH"
!ll&&!rl&&r
1265
MC/DC100%2/2
$doc and ref $doc eq "HASH"
$doc ref $doc eq "HASH"
Truth table100%3/3
A and B
A= $docB= ref $doc eq "HASH"
ABresult
0X0
100
111
1397  
1398 65 ▶ if ($collect_errors) {
Branch: 1 branch
BranchTrueFalseTotal
if ($collect_errors) { } 8 57 65
1399 8 eval { push @objects, $self->inflate($doc) };
1400 8 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 5 3 8
1401 5 ▶ my $name = $doc->{metadata}{name} // "document $i";
Condition50%1/2
$doc->{"metadata"}{"name"} // "document $i"
l!l
50
MC/DC0%0/1
$doc->{"metadata"}{"name"} // "document $i"
$doc->{"metadata"}{"name"}
Truth table50%1/2
A
A= $doc->{"metadata"}{"name"}
Aresult
11
00
1402 5 ▶ my $kind = $doc->{kind} // 'unknown';
Condition50%1/2
$doc->{"kind"} // "unknown"
l!l
50
MC/DC0%0/1
$doc->{"kind"} // "unknown"
$doc->{"kind"}
Truth table50%1/2
A
A= $doc->{"kind"}
Aresult
11
00
1403 5 push @errors, "$kind/$name: $@";
1404 }
1405 } else {
1406 57 push @objects, $self->inflate($doc);
1407 }
1408 }
1409  
1410 # In collect_errors mode, return (objects, errors) in list context
1411 61 ▶ if ($collect_errors) {
Branch: 1 branch
BranchTrueFalseTotal
if ($collect_errors) 5 56 61
1412 5 return (\@objects, \@errors);
1413 }
1414  
1415 56 return \@objects;
1416 }
1417  
1418 # The YAML::PP both loaders parse with (k198). kubectl reads manifests as
1419 # YAML 1.1, so 'privileged: no' is false and 'defaultMode: 0644' is 420;
1420 # the YAML 1.2 core schema YAML::PP defaults to reads them as the string
1421 # 'no' (a true Bool) and 644. The 1.1 forms are registered ahead of the 1.2
1422 # core schema, which stays underneath for everything else, so what loaded
1423 # before still loads the same (0o644, 0x1A4, 1e3, true/false). The 1.1
1424 # schema YAML::PP ships is not used as is: it also reads 22:22 or 10:30 as a
1425 # sexagesimal number, which kubectl does not, and a string field would
1426 # silently turn into 1342. Only the booleans (y n yes no on off in every
1427 # spelling YAML 1.1 knows) and the leading-zero octal integers are added.
1428 # Takes YAML::PP's 'boolean' setting, so each caller keeps its own.
1429 122 ▶sub _yaml_parser {
Subroutine _yaml_parser: called CC=5 SCAR=16.1
1430 122 my ($self, $boolean) = @_;
1431 122 require YAML::PP;
1432 122 require YAML::PP::Schema;
1433  
1434 122 ▶ my $schema = YAML::PP::Schema->new(
Branch: 1 branch
BranchTrueFalseTotal
defined $boolean ? : 53 69 122
1435 yaml_version => '1.2',
1436 defined $boolean ? ( boolean => $boolean ) : (),
1437 );
1438 # A mapping key stays the text as written: 'y:', 'on:' or 'no:' is the
1439 # key "y", "on", "no", not a boolean (which YAML::PP would turn into a
1440 # "Duplicate key" croak for two of them, or a mangled key). That is a
1441 # deliberate difference from kubectl, which reads them as "true"/"false"
1442 # and so breaks CRD properties named 'on' or 'y'. A scalar is a key when
1443 # the innermost open mapping holds an even number of nodes so far.
1444 122 my ( $true, $false ) = ( $schema->true, $schema->false ); # not $schema itself: no cycle
1445 336 ▶ my $in_key = sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
1446 336 my ($constructor) = @_;
1447 336 my $top = $constructor->stack->[-1];
1448 336 ▶ return $top && $top->{type} eq 'mapping' && !( @{ $top->{ref} } % 2 );
Condition83%5/6
$top && $top->{'type'} eq 'mapping' && !(@{$top->{'ref'};} % 2)
!ll&&!rl&&r
231717
$top and $top->{"type"} eq "mapping"
!ll&&!rl&&r
02334
MC/DC66%2/3
$top && $top->{'type'} eq 'mapping' && !(@{$top->{'ref'};} % 2)
$top $top->{"type"} eq "mapping" !(@{$top->{'ref'};} % 2)
Truth table75%3/4
A and B && not(C)
A= $topB= $top->{"type"} eq "mapping"C= !(@{$top->{'ref'};} % 2)
ABCresult
0XX0
10X0
1100
1111
1449 122 };
1450 122 for my $word ( qw( y Y yes Yes YES on On ON true True TRUE ) ) {
1451 $schema->add_resolver(
1452 tag => 'tag:yaml.org,2002:bool',
1453 196 ▶ match => [ equals => $word => sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
1454 196 my ( $constructor, $event ) = @_;
1455 196 ▶ return $in_key->($constructor) ? $event->{value} : $true->(@_);
Branch: 1 branch
BranchTrueFalseTotal
&$in_key($constructor) ? : 9 187 196
1456 1342 } ],
1457 );
1458 }
1459 122 for my $word ( qw( n N no No NO off Off OFF false False FALSE ) ) {
1460 $schema->add_resolver(
1461 tag => 'tag:yaml.org,2002:bool',
1462 106 ▶ match => [ equals => $word => sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
1463 106 my ( $constructor, $event ) = @_;
1464 106 ▶ return $in_key->($constructor) ? $event->{value} : $false->(@_);
Branch: 1 branch
BranchTrueFalseTotal
&$in_key($constructor) ? : 7 99 106
1465 1342 } ],
1466 );
1467 }
1468 $schema->add_resolver(
1469 tag => 'tag:yaml.org,2002:int',
1470 34 ▶ match => [ regex => qr{^([+-]?)0([0-7][0-7_]*)$} => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
1471 34 my ( $constructor, $event, $matches ) = @_;
1472 34 ▶ return $event->{value} if $in_key->($constructor);
Branch: 1 branch
BranchTrueFalseTotal
if &$in_key($constructor) 1 33 34
1473 33 my ( $sign, $digits ) = @$matches;
1474 33 $digits =~ tr/_//d;
1475 33 ▶ return ( $sign eq '-' ? -1 : 1 ) * oct $digits;
Branch: 1 branch
BranchTrueFalseTotal
$sign eq '-' ? : 0 33 33
1476 122 } ],
1477 );
1478 122 $schema->load_subschemas('Core');
1479  
1480 122 ▶ return YAML::PP->new(
Branch: 1 branch
BranchTrueFalseTotal
defined $boolean ? : 53 69 122
1481 schema => $schema,
1482 defined $boolean ? ( boolean => $boolean ) : (),
1483 );
1484 }
1485  
1486 # The YAML documents in a load_yaml or IO::K8s::CRD->load argument: one
1487 # argument, two readings (k159, k162). Without a newline it may name a
1488 # file: an existing one is read as UTF-8, a directory is refused.
1489 # Everything else is YAML text, expected as decoded characters and parsed
1490 # as given, never re-encoded. A one-line argument that is no file and
1491 # parses to plain scalars only, not a single mapping or sequence, is a path
1492 # with a typo -- 'manifests/app.yaml' is valid YAML for that very string --
1493 # and used to come back as [] without a word. Empty or whitespace-only
1494 # text, a bare '---' or a comment parse to nothing defined and still give
1495 # no documents.
1496 #
1497 # $yaml is the caller's YAML::PP, so each keeps its own boolean setting.
1498 # Returns undef and the documents, or a refusal to follow the quoted
1499 # argument in the caller's croak. The callers croak themselves, with their
1500 # own name: a croak from in here would be reported at IO::K8s::CRD's line,
1501 # not at its caller's.
1502 121 ▶sub _yaml_documents {
Subroutine _yaml_documents: called CC=9 SCAR=22.0
1503 121 my ($self, $file_or_string, $yaml) = @_;
1504 121 my $one_line = $file_or_string !~ /\n/;
1505 121 ▶ return 'is a directory, not a file or YAML text' if $one_line && -d $file_or_string;
Branch: 1 branch
BranchTrueFalseTotal
if $one_line and -d $file_or_string 3 118 121
Condition100%3/3
$one_line and -d $file_or_string
!ll&&!rl&&r
60583
MC/DC100%2/2
$one_line and -d $file_or_string
$one_line -d $file_or_string
Truth table100%3/3
A and B
A= $one_lineB= -d $file_or_string
ABresult
0X0
100
111
1506 118 ▶ my $is_file = $one_line && -f $file_or_string;
Condition100%3/3
$one_line && -f $file_or_string
!ll&&!rl&&r
602335
MC/DC100%2/2
$one_line && -f $file_or_string
$one_line -f $file_or_string
Truth table100%3/3
A && B
A= $one_lineB= -f $file_or_string
ABresult
0X0
100
111
1507 118 ▶ my @docs = $yaml->load_string($is_file ? $self->_slurp_utf8($file_or_string) : $file_or_string);
Branch: 1 branch
BranchTrueFalseTotal
$is_file ? : 35 83 118
1508 return 'is neither an existing file nor YAML text'
1509 116 ▶ if $one_line && !$is_file && !grep({ ref } @docs) && grep({ defined } @docs);
Branch: 1 branch
BranchTrueFalseTotal
if $one_line and not $is_file and not grep({ref $_;} @docs) and grep {defined $_;} @docs 10 106 116
Condition100%9/9
$one_line and not $is_file and not grep({ref $_;} @docs) and grep {defined $_;} @docs
!ll&&!rl&&r
97910
$one_line and not $is_file and not grep({ref $_;} @docs)
!ll&&!rl&&r
93419
$one_line and not $is_file
!ll&&!rl&&r
603323
MC/DC100%4/4
$one_line and not $is_file and not grep({ref $_;} @docs) and grep {defined $_;} @docs
$one_line not $is_file not grep({ref $_;} @docs) grep {defined $_;} @docs
Truth table100%5/5
A and not(B) and not(C) and D
A= $one_lineB= not $is_fileC= not grep({ref $_;} @docs)D= grep {defined $_;} @docs
ABCDresult
0XXX0
10XX0
110X0
11100
11111
1510 106 return (undef, @docs);
1511 }
1512  
1513 # A whole file as text, read as UTF-8 -- the encoding Kubernetes manifests
1514 # are written in, and YAML::PP and a string eval both want characters, not
1515 # bytes (k159, k160). IO::K8s::CRD->load reads a file through it as well,
1516 # by way of _yaml_documents (k162).
1517 87 ▶sub _slurp_utf8 {
Subroutine _slurp_utf8: called CC=2 SCAR=6.9
1518 87 my ($self, $file) = @_;
1519 87 ▶ open my $fh, '<:encoding(UTF-8)', $file or croak 'Cannot open '.$file.': '.$!;
Branch: 1 branch
BranchTrueFalseTotal
open my $fh, "<:encoding(UTF-8)", $file or croak('Cannot open ' . $file . ': ' . $!) 84 3 87
1520 84 my $content = do { local $/; <$fh> };
1521 84 close $fh;
1522 84 return $content;
1523 }
1524  
1525 148 1;
1526  
1527 __END__
« lib/IO/K8s/List.pm ↑ Summary blib/lib/IO/K8s/Role/SpecBuilder.pm »