17945326072

Committed 23 Sep 2025 11:53AM UTC coverage: 86.981% (+0.03%) from 86.951%

Build # 17945326072

Build Type

push

github

Committed by

vsouz4

Commit Message

release fix nullable enum

Run Details

2993 of 3441 relevant lines covered (86.98%)

6.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.46

/src/Generator/SchemaGenerator.php

<?php

declare(strict_types=1);

namespace DoclerLabs\ApiClientGenerator\Generator;

use DateTimeInterface;
use DoclerLabs\ApiClientGenerator\Ast\Builder\ParameterBuilder;
use DoclerLabs\ApiClientGenerator\Ast\ParameterNode;
use DoclerLabs\ApiClientGenerator\Entity\Field;
use DoclerLabs\ApiClientGenerator\Entity\FieldType;
use DoclerLabs\ApiClientGenerator\Input\Specification;
use DoclerLabs\ApiClientGenerator\Output\Php\PhpFileCollection;
use JsonSerializable;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\ClassMethod;
use UnexpectedValueException;

class SchemaGenerator extends MutatorAccessorClassGeneratorAbstract
{
    public const SUBDIRECTORY = 'Schema/';

    public const NAMESPACE_SUBPATH = '\\Schema';

    private const OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME = 'optionalPropertyChanged';

    public function generate(Specification $specification, PhpFileCollection $fileRegistry): void
    {
        $compositeFields = $specification->getCompositeFields()->getUniqueByPhpClassName();
        foreach ($compositeFields as $field) {
            if ($field->isObject() && !$field->isFreeFormObject()) {
                $this->generateSchema($field, $fileRegistry);
            }
        }
    }

    protected function generateSchema(Field $root, PhpFileCollection $fileRegistry): void
    {
        $this->addImport(JsonSerializable::class);

        $className = $root->getPhpClassName();

        $classBuilder = $this
            ->builder
            ->class($className)
            ->implement('SerializableInterface', 'JsonSerializable')
            ->addStmts($this->generateEnumConsts($root))
            ->addStmts($this->generateProperties($root))
            ->addStmt($this->generateOptionalChangedFieldsProperty($root))
            ->addStmt($this->generateConstructor($root))
            ->addStmts($this->generateSetMethods($root))
            ->addStmts($this->generateHasMethods($root))
            ->addStmts($this->generateGetMethods($root))
            ->addStmt($this->generateToArray($root))
            ->addStmt($this->generateJsonSerialize());

        $this->registerFile($fileRegistry, $classBuilder, self::SUBDIRECTORY, self::NAMESPACE_SUBPATH);
    }

    private function generateOptionalChangedFieldsProperty(Field $root): ?Stmt
    {
        $optionalProperties = [];

        foreach ($root->getObjectProperties() as $propertyField) {
            if ($propertyField->isOptional()) {
                if ($propertyField->getPhpVariableName() === self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME) {
                    throw new UnexpectedValueException('Property "' . self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME . '" not supported!');
                }

                if ($propertyField->isNullable()) {
                    trigger_error('Property "' . $propertyField->getName() . '" is nullable and optional, that might be a sign of a bad api design', E_USER_WARNING);
                }
                $optionalProperties[] = $propertyField;
            }
        }

        if (empty($optionalProperties)) {
            return null;
        }

        $propertyArrayValues = [];
        foreach ($optionalProperties as $optionalProperty) {
            $propertyArrayValues[$optionalProperty->getPhpVariableName()] = $this->builder->val(false);
        }

        return $this->builder->localProperty(
            self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME,
            'array',
            'array',
            false,
            $this->builder->array($propertyArrayValues)
        );
    }

    protected function generateEnumConsts(Field $root): array
    {
        $statements = [];
        foreach ($root->getObjectProperties() as $propertyField) {
            foreach ($this->generateEnumStatements($propertyField) as $statement) {
                $statements[] = $statement;
            }
        }

        return $statements;
    }

    protected function generateProperties(Field $root): array
    {
        $statements = [];
        foreach ($root->getObjectProperties() as $propertyField) {
            if ($propertyField->isDate()) {
                $this->addImport(DateTimeInterface::class);
            }
            if (
                $propertyField->isRequired()
                && $this->phpVersion->isConstructorPropertyPromotionSupported()
            ) {
                continue;
            }

            $statements[] = $this->generateProperty($propertyField);
        }

        return $statements;
    }

    protected function generateConstructor(Field $root): ?ClassMethod
    {
        $params             = [];
        $validations        = [];
        $paramsInit         = [];
        $paramsDoc          = [];
        $thrownExceptionMap = [];

        foreach ($root->getObjectProperties() as $propertyField) {
            if ($propertyField->isRequired()) {
                $validationStmts = $this->generateValidationStmts($propertyField);
                array_push($validations, ...$validationStmts);
                if (!empty($validationStmts)) {
                    $thrownExceptionMap['RequestValidationException'] = true;
                }
                $params[] = $this->builder
                    ->param($propertyField->getPhpVariableName())
                    ->setType($propertyField->getPhpTypeHint(), $propertyField->isNullable());

                $paramsInit[] = $this->builder->assign(
                    $this->builder->localPropertyFetch($propertyField->getPhpVariableName()),
                    $this->builder->var($propertyField->getPhpVariableName())
                );

                $paramsDoc[] = $this->builder
                    ->param($propertyField->getPhpVariableName())
                    ->setType($propertyField->getPhpTypeHint(), $propertyField->isNullable())
                    ->setDocBlockType($propertyField->getPhpDocType($propertyField->isNullable()))
                    ->getNode();
            }
        }
        if (empty($params)) {
            return null;
        }

        if ($this->phpVersion->isConstructorPropertyPromotionSupported()) {
            foreach ($params as $param) {
                $param->makePrivate();
            }
        }
        if ($this->phpVersion->isReadonlyPropertySupported()) {
            foreach ($params as $param) {
                $param->makeReadonly();
            }
        }

        $params = array_map(
            static fn (ParameterBuilder $param): ParameterNode => $param->getNode(),
            $params
        );

        $constructor = $this
            ->builder
            ->method('__construct')
            ->makePublic()
            ->addParams($params)
            ->addStmts($validations)
            ->composeDocBlock($paramsDoc, '', array_keys($thrownExceptionMap));

        if (!$this->phpVersion->isConstructorPropertyPromotionSupported()) {
            $constructor->addStmts($paramsInit);
        }

        return $constructor->getNode();
    }

    protected function generateSetMethods(Field $root): array
    {
        $statements = [];
        foreach ($root->getObjectProperties() as $propertyField) {
            if ($propertyField->isOptional()) {
                $changedFieldSetter = $this->builder->assign(
                    $this->builder->getArrayItem(
                        $this->builder->localPropertyFetch(self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME),
                        $this->builder->val($propertyField->getPhpVariableName())
                    ),
                    $this->builder->val(true)
                );

                $statements[] = $this->generateSet($propertyField, [$changedFieldSetter]);
            }
        }

        return $statements;
    }

    protected function generateGetMethods(Field $root): array
    {
        $statements = [];
        foreach ($root->getObjectProperties() as $propertyField) {
            $statements[] = $this->generateGet($propertyField);
        }

        return $statements;
    }

    protected function generateHasMethods(Field $root): array
    {
        $statements = [];
        foreach ($root->getObjectProperties() as $propertyField) {
            if ($propertyField->isOptional()) {
                $statements[] = $this->generateHas($propertyField);
            }
        }

        return $statements;
    }

    protected function generateToArray(Field $root): ClassMethod
    {
        $statements    = [];
        $arrayVariable = $this->builder->var('fields');
        $initialValue  = $this->builder->val([]);

        $statements[] = $this->builder->assign($arrayVariable, $initialValue);
        $statements   = array_merge($statements, $this->collectSerializationFields($root, $arrayVariable));
        $statements[] = $this->builder->return($arrayVariable);

        $returnType = FieldType::PHP_TYPE_ARRAY;

        return $this
            ->builder
            ->method('toArray')
            ->makePublic()
            ->addStmts($statements)
            ->setReturnType($returnType)
            ->composeDocBlock([], $returnType)
            ->getNode();
    }

    private function generateHas(Field $field): ClassMethod
    {
        $return = $this->builder->return(
            $this->builder->getArrayItem(
                $this->builder->localPropertyFetch(
                    self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME
                ),
                $this->builder->val($field->getPhpVariableName())
            )
        );

        return $this->builder
            ->method($this->getHasMethodName($field))
            ->makePublic()
            ->addStmt($return)
            ->setReturnType('bool')
            ->composeDocBlock([], 'bool')
            ->getNode();
    }

    private function collectSerializationFields(Field $root, Variable $arrayVariable): array
    {
        $statements = [];
        foreach ($root->getObjectProperties() as $propertyField) {
            $value = $this->builder->localPropertyFetch($propertyField->getPhpVariableName());
            if ($propertyField->isComposite()) {
                $methodCall = $this->builder->methodCall($value, 'toArray');
                if ($propertyField->isNullable()) {
                    if ($this->phpVersion->isNullSafeSupported()) {
                        $value = $this->builder->nullsafeMethodCall($value, 'toArray');
                    } else {
                        $value = $this->builder->ternary(
                            $this->builder->notEquals($value, $this->builder->val(null)),
                            $methodCall,
                            $this->builder->val(null)
                        );
                    }
                } else {
                    $value = $methodCall;
                }
            } elseif ($propertyField->isDate()) {
                $methodCall = $this->builder->methodCall(
                    $value,
                    'format',
                    [$this->builder->constFetch('DATE_RFC3339')]
                );

                if ($propertyField->isNullable()) {
                    if ($this->phpVersion->isNullSafeSupported()) {
                        $value = $this->builder->nullsafeMethodCall(
                            $value,
                            'format',
                            [$this->builder->constFetch('DATE_RFC3339')]
                        );
                    } else {
                        $value = $this->builder->ternary(
                            $this->builder->notEquals($value, $this->builder->val(null)),
                            $methodCall,
                            $this->builder->val(null)
                        );
                    }
                } else {
                    $value = $methodCall;
                }
            } elseif ($propertyField->isEnum() && $this->phpVersion->isEnumSupported()) {
                $value = $propertyField->isNullable()
                    ? $this->builder->nullsafePropertyFetch($value, 'value')
                    : $this->builder->propertyFetch($value, 'value');
            } elseif ($propertyField->isArrayOfEnums() && $this->phpVersion->isEnumSupported()) {
                $enumField    = $propertyField->getArrayItem();
                $arrayMapCall = $this->builder->funcCall(
                    'array_map',
                    [
                        $this->builder->arrowFunction(
                            $this->builder->propertyFetch($this->builder->var('item'), 'value'),
                            [$this->builder->param('item')->setType($enumField->getPhpClassName())->getNode()],
                            $enumField->getType()->toPhpType(),
                        ),
                        $value,
                    ]
                );

                $value = $propertyField->isNullable()
                    ? $this->builder->ternary(
                        $this->builder->notEquals($value, $this->builder->val(null)),
                        $arrayMapCall,
                        $this->builder->val(null)
                    )
                    : $arrayMapCall;
            }

            $fieldName = $this->builder->val($propertyField->getName());
            if ($root->hasOneOf()) {
                $assignStatement = $this->builder->expr($this->builder->assign($arrayVariable, $value));
            } else {
                $assignStatement = $this->builder->appendToAssociativeArray($arrayVariable, $fieldName, $value);
            }

            if ($propertyField->isOptional()) {
                $ifCondition = $this->builder->localMethodCall(
                    $this->getHasMethodName($propertyField)
                );

                $statements[] = $this->builder->if($ifCondition, [$assignStatement]);
            } else {
                $statements[] = $assignStatement;
            }
        }

        return $statements;
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace DoclerLabs\ApiClientGenerator\Generator;
6
7	use DateTimeInterface;
8	use DoclerLabs\ApiClientGenerator\Ast\Builder\ParameterBuilder;
9	use DoclerLabs\ApiClientGenerator\Ast\ParameterNode;
10	use DoclerLabs\ApiClientGenerator\Entity\Field;
11	use DoclerLabs\ApiClientGenerator\Entity\FieldType;
12	use DoclerLabs\ApiClientGenerator\Input\Specification;
13	use DoclerLabs\ApiClientGenerator\Output\Php\PhpFileCollection;
14	use JsonSerializable;
15	use PhpParser\Node\Expr\Variable;
16	use PhpParser\Node\Stmt;
17	use PhpParser\Node\Stmt\ClassMethod;
18	use UnexpectedValueException;
19
20	class SchemaGenerator extends MutatorAccessorClassGeneratorAbstract
21	{
22	public const SUBDIRECTORY = 'Schema/';
23
24	public const NAMESPACE_SUBPATH = '\\Schema';
25
26	private const OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME = 'optionalPropertyChanged';
27
28	public function generate(Specification $specification, PhpFileCollection $fileRegistry): void
29	{
30	$compositeFields = $specification->getCompositeFields()->getUniqueByPhpClassName();	19✔
31	foreach ($compositeFields as $field) {	19✔
32	if ($field->isObject() && !$field->isFreeFormObject()) {	19✔
33	$this->generateSchema($field, $fileRegistry);	19✔
34	}
35	}
36	}	19✔
37
38	protected function generateSchema(Field $root, PhpFileCollection $fileRegistry): void
39	{
40	$this->addImport(JsonSerializable::class);	19✔
41
42	$className = $root->getPhpClassName();	19✔
43
44	$classBuilder = $this	19✔
45	->builder	19✔
46	->class($className)	19✔
47	->implement('SerializableInterface', 'JsonSerializable')	19✔
48	->addStmts($this->generateEnumConsts($root))	19✔
49	->addStmts($this->generateProperties($root))	19✔
50	->addStmt($this->generateOptionalChangedFieldsProperty($root))	19✔
51	->addStmt($this->generateConstructor($root))	19✔
52	->addStmts($this->generateSetMethods($root))	19✔
53	->addStmts($this->generateHasMethods($root))	19✔
54	->addStmts($this->generateGetMethods($root))	19✔
55	->addStmt($this->generateToArray($root))	19✔
56	->addStmt($this->generateJsonSerialize());	19✔
57
58	$this->registerFile($fileRegistry, $classBuilder, self::SUBDIRECTORY, self::NAMESPACE_SUBPATH);	19✔
59	}	19✔
60
61	private function generateOptionalChangedFieldsProperty(Field $root): ?Stmt
62	{
63	$optionalProperties = [];	19✔
64
65	foreach ($root->getObjectProperties() as $propertyField) {	19✔
66	if ($propertyField->isOptional()) {	19✔
67	if ($propertyField->getPhpVariableName() === self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME) {	19✔
68	throw new UnexpectedValueException('Property "' . self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME . '" not supported!');	×
69	}
70
71	if ($propertyField->isNullable()) {	19✔
72	trigger_error('Property "' . $propertyField->getName() . '" is nullable and optional, that might be a sign of a bad api design', E_USER_WARNING);	19✔
73	}
74	$optionalProperties[] = $propertyField;	19✔
75	}
76	}
77
78	if (empty($optionalProperties)) {	19✔
79	return null;	×
80	}
81
82	$propertyArrayValues = [];	19✔
83	foreach ($optionalProperties as $optionalProperty) {	19✔
84	$propertyArrayValues[$optionalProperty->getPhpVariableName()] = $this->builder->val(false);	19✔
85	}
86
87	return $this->builder->localProperty(	19✔
88	self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME,	19✔
89	'array',	19✔
90	'array',	19✔
91	false,	19✔
92	$this->builder->array($propertyArrayValues)	19✔
93	);
94	}
95
96	protected function generateEnumConsts(Field $root): array
97	{
98	$statements = [];	19✔
99	foreach ($root->getObjectProperties() as $propertyField) {	19✔
100	foreach ($this->generateEnumStatements($propertyField) as $statement) {	19✔
101	$statements[] = $statement;	13✔
102	}
103	}
104
105	return $statements;	19✔
106	}
107
108	protected function generateProperties(Field $root): array
109	{
110	$statements = [];	19✔
111	foreach ($root->getObjectProperties() as $propertyField) {	19✔
112	if ($propertyField->isDate()) {	19✔
113	$this->addImport(DateTimeInterface::class);	16✔
114	}
115	if (
116	$propertyField->isRequired()	19✔
117	&& $this->phpVersion->isConstructorPropertyPromotionSupported()	19✔
118	) {
119	continue;	7✔
120	}
121
122	$statements[] = $this->generateProperty($propertyField);	19✔
123	}
124
125	return $statements;	19✔
126	}
127
128	protected function generateConstructor(Field $root): ?ClassMethod
129	{
130	$params = [];	19✔
131	$validations = [];	19✔
132	$paramsInit = [];	19✔
133	$paramsDoc = [];	19✔
134	$thrownExceptionMap = [];	19✔
135
136	foreach ($root->getObjectProperties() as $propertyField) {	19✔
137	if ($propertyField->isRequired()) {	19✔
138	$validationStmts = $this->generateValidationStmts($propertyField);	19✔
139	array_push($validations, ...$validationStmts);	19✔
140	if (!empty($validationStmts)) {	19✔
141	$thrownExceptionMap['RequestValidationException'] = true;	14✔
142	}
143	$params[] = $this->builder	19✔
144	->param($propertyField->getPhpVariableName())	19✔
145	->setType($propertyField->getPhpTypeHint(), $propertyField->isNullable());	19✔
146
147	$paramsInit[] = $this->builder->assign(	19✔
148	$this->builder->localPropertyFetch($propertyField->getPhpVariableName()),	19✔
149	$this->builder->var($propertyField->getPhpVariableName())	19✔
150	);
151
152	$paramsDoc[] = $this->builder	19✔
153	->param($propertyField->getPhpVariableName())	19✔
154	->setType($propertyField->getPhpTypeHint(), $propertyField->isNullable())	19✔
155	->setDocBlockType($propertyField->getPhpDocType($propertyField->isNullable()))	19✔
156	->getNode();	19✔
157	}
158	}
159	if (empty($params)) {	19✔
160	return null;	16✔
161	}
162
163	if ($this->phpVersion->isConstructorPropertyPromotionSupported()) {	19✔
164	foreach ($params as $param) {	7✔
165	$param->makePrivate();	7✔
166	}
167	}
168	if ($this->phpVersion->isReadonlyPropertySupported()) {	19✔
169	foreach ($params as $param) {	5✔
170	$param->makeReadonly();	5✔
171	}
172	}
173
174	$params = array_map(	19✔
175	static fn (ParameterBuilder $param): ParameterNode => $param->getNode(),	19✔
176	$params
177	);
178
179	$constructor = $this	19✔
180	->builder	19✔
181	->method('__construct')	19✔
182	->makePublic()	19✔
183	->addParams($params)	19✔
184	->addStmts($validations)	19✔
185	->composeDocBlock($paramsDoc, '', array_keys($thrownExceptionMap));	19✔
186
187	if (!$this->phpVersion->isConstructorPropertyPromotionSupported()) {	19✔
188	$constructor->addStmts($paramsInit);	12✔
189	}
190
191	return $constructor->getNode();	19✔
192	}
193
194	protected function generateSetMethods(Field $root): array
195	{
196	$statements = [];	19✔
197	foreach ($root->getObjectProperties() as $propertyField) {	19✔
198	if ($propertyField->isOptional()) {	19✔
199	$changedFieldSetter = $this->builder->assign(	19✔
200	$this->builder->getArrayItem(	19✔
201	$this->builder->localPropertyFetch(self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME),	19✔
202	$this->builder->val($propertyField->getPhpVariableName())	19✔
203	),
204	$this->builder->val(true)	19✔
205	);
206
207	$statements[] = $this->generateSet($propertyField, [$changedFieldSetter]);	19✔
208	}
209	}
210
211	return $statements;	19✔
212	}
213
214	protected function generateGetMethods(Field $root): array
215	{
216	$statements = [];	19✔
217	foreach ($root->getObjectProperties() as $propertyField) {	19✔
218	$statements[] = $this->generateGet($propertyField);	19✔
219	}
220
221	return $statements;	19✔
222	}
223
224	protected function generateHasMethods(Field $root): array
225	{
226	$statements = [];	19✔
227	foreach ($root->getObjectProperties() as $propertyField) {	19✔
228	if ($propertyField->isOptional()) {	19✔
229	$statements[] = $this->generateHas($propertyField);	19✔
230	}
231	}
232
233	return $statements;	19✔
234	}
235
236	protected function generateToArray(Field $root): ClassMethod
237	{
238	$statements = [];	19✔
239	$arrayVariable = $this->builder->var('fields');	19✔
240	$initialValue = $this->builder->val([]);	19✔
241
242	$statements[] = $this->builder->assign($arrayVariable, $initialValue);	19✔
243	$statements = array_merge($statements, $this->collectSerializationFields($root, $arrayVariable));	19✔
244	$statements[] = $this->builder->return($arrayVariable);	19✔
245
246	$returnType = FieldType::PHP_TYPE_ARRAY;	19✔
247
248	return $this
249	->builder	19✔
250	->method('toArray')	19✔
251	->makePublic()	19✔
252	->addStmts($statements)	19✔
253	->setReturnType($returnType)	19✔
254	->composeDocBlock([], $returnType)	19✔
255	->getNode();	19✔
256	}
257
258	private function generateHas(Field $field): ClassMethod
259	{
260	$return = $this->builder->return(	19✔
261	$this->builder->getArrayItem(	19✔
262	$this->builder->localPropertyFetch(	19✔
263	self::OPTIONAL_CHANGED_FIELDS_PROPERTY_NAME	19✔
264	),
265	$this->builder->val($field->getPhpVariableName())	19✔
266	)
267	);
268
269	return $this->builder	19✔
270	->method($this->getHasMethodName($field))	19✔
271	->makePublic()	19✔
272	->addStmt($return)	19✔
273	->setReturnType('bool')	19✔
274	->composeDocBlock([], 'bool')	19✔
275	->getNode();	19✔
276	}
277
278	private function collectSerializationFields(Field $root, Variable $arrayVariable): array
279	{
280	$statements = [];	19✔
281	foreach ($root->getObjectProperties() as $propertyField) {	19✔
282	$value = $this->builder->localPropertyFetch($propertyField->getPhpVariableName());	19✔
283	if ($propertyField->isComposite()) {	19✔
284	$methodCall = $this->builder->methodCall($value, 'toArray');	16✔
285	if ($propertyField->isNullable()) {	16✔
286	if ($this->phpVersion->isNullSafeSupported()) {	14✔
287	$value = $this->builder->nullsafeMethodCall($value, 'toArray');	6✔
288	} else {
289	$value = $this->builder->ternary(	8✔
290	$this->builder->notEquals($value, $this->builder->val(null)),	8✔
291	$methodCall,
292	$this->builder->val(null)	8✔
293	);
294	}
295	} else {
296	$value = $methodCall;	16✔
297	}
298	} elseif ($propertyField->isDate()) {	19✔
299	$methodCall = $this->builder->methodCall(	16✔
300	$value,
301	'format',	16✔
302	[$this->builder->constFetch('DATE_RFC3339')]	16✔
303	);
304
305	if ($propertyField->isNullable()) {	16✔
306	if ($this->phpVersion->isNullSafeSupported()) {	14✔
307	$value = $this->builder->nullsafeMethodCall(	6✔
308	$value,
309	'format',	6✔
310	[$this->builder->constFetch('DATE_RFC3339')]	6✔
311	);
312	} else {
313	$value = $this->builder->ternary(	8✔
314	$this->builder->notEquals($value, $this->builder->val(null)),	8✔
315	$methodCall,
316	$this->builder->val(null)	8✔
317	);
318	}
319	} else {
320	$value = $methodCall;	16✔
321	}
322	} elseif ($propertyField->isEnum() && $this->phpVersion->isEnumSupported()) {	19✔
323	$value = $propertyField->isNullable()	4✔
324	? $this->builder->nullsafePropertyFetch($value, 'value')	3✔
325	: $this->builder->propertyFetch($value, 'value');	4✔
326	} elseif ($propertyField->isArrayOfEnums() && $this->phpVersion->isEnumSupported()) {	19✔
327	$enumField = $propertyField->getArrayItem();	1✔
328	$arrayMapCall = $this->builder->funcCall(	1✔
329	'array_map',	1✔
330	[
331	$this->builder->arrowFunction(	1✔
332	$this->builder->propertyFetch($this->builder->var('item'), 'value'),	1✔
333	[$this->builder->param('item')->setType($enumField->getPhpClassName())->getNode()],	1✔
334	$enumField->getType()->toPhpType(),	1✔
335	),
336	$value,	1✔
337	]
338	);
339
340	$value = $propertyField->isNullable()	1✔
341	? $this->builder->ternary(	1✔
342	$this->builder->notEquals($value, $this->builder->val(null)),	1✔
343	$arrayMapCall,
344	$this->builder->val(null)	1✔
345	)
346	: $arrayMapCall;	1✔
347	}
348
349	$fieldName = $this->builder->val($propertyField->getName());	19✔
350	if ($root->hasOneOf()) {	19✔
351	$assignStatement = $this->builder->expr($this->builder->assign($arrayVariable, $value));	×
352	} else {
353	$assignStatement = $this->builder->appendToAssociativeArray($arrayVariable, $fieldName, $value);	19✔
354	}
355
356	if ($propertyField->isOptional()) {	19✔
357	$ifCondition = $this->builder->localMethodCall(	19✔
358	$this->getHasMethodName($propertyField)	19✔
359	);
360
361	$statements[] = $this->builder->if($ifCondition, [$assignStatement]);	19✔
362	} else {
363	$statements[] = $assignStatement;	19✔
364	}
365	}
366
367	return $statements;	19✔
368	}
369	}

DoclerLabs / api-client-generator / 17945326072

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous