4564420247

Build # 4564420247

Build Type

github

Committed by GitHub

Commit Message

Merge 3a8dbf1f2 into 1294d211a

Pull Request Pull Request #68: Fix recursive reference resolving

Run Details

288 of 288 new or added lines in 39 files covered. (100.0%)

2777 of 2813 relevant lines covered (98.72%)

526.99 hits per line

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

98.65

/src/PropertyProcessor/Property/MultiTypeProcessor.php

<?php

declare(strict_types = 1);

namespace PHPModelGenerator\PropertyProcessor\Property;

use PHPModelGenerator\Exception\SchemaException;
use PHPModelGenerator\Model\Property\PropertyInterface;
use PHPModelGenerator\Model\Schema;
use PHPModelGenerator\Model\SchemaDefinition\JsonSchema;
use PHPModelGenerator\Model\Validator\MultiTypeCheckValidator;
use PHPModelGenerator\Model\Validator\TypeCheckInterface;
use PHPModelGenerator\PropertyProcessor\Decorator\Property\PropertyTransferDecorator;
use PHPModelGenerator\PropertyProcessor\Decorator\TypeHint\TypeHintDecorator;
use PHPModelGenerator\PropertyProcessor\PropertyMetaDataCollection;
use PHPModelGenerator\PropertyProcessor\PropertyProcessorFactory;
use PHPModelGenerator\PropertyProcessor\PropertyProcessorInterface;
use PHPModelGenerator\SchemaProcessor\SchemaProcessor;
use ReflectionException;

/**
 * Class MultiTypePropertyProcessor
 *
 * @package PHPModelGenerator\PropertyProcessor\Property
 */
class MultiTypeProcessor extends AbstractValueProcessor
{
    /** @var PropertyProcessorInterface[] */
    protected $propertyProcessors = [];
    /** @var string[] */
    protected $allowedPropertyTypes = [];
    /** @var string[] */
    protected $checks = [];

    /**
     * MultiTypePropertyProcessor constructor.
     *
     * @param PropertyProcessorFactory   $propertyProcessorFactory
     * @param array                      $types
     * @param PropertyMetaDataCollection $propertyMetaDataCollection
     * @param SchemaProcessor            $schemaProcessor
     * @param Schema                     $schema
     *
     * @throws SchemaException
     */
    public function __construct(
        PropertyProcessorFactory $propertyProcessorFactory,
        array $types,
        PropertyMetaDataCollection $propertyMetaDataCollection,
        SchemaProcessor $schemaProcessor,
        Schema $schema
    ) {
        parent::__construct($propertyMetaDataCollection, $schemaProcessor, $schema);

        foreach ($types as $type) {
            $this->propertyProcessors[$type] = $propertyProcessorFactory->getProcessor(
                $type,
                $propertyMetaDataCollection,
                $schemaProcessor,
                $schema
            );
        }
    }

    /**
     * Process a property
     *
     * @param string $propertyName The name of the property
     * @param JsonSchema $propertySchema The schema of the property
     *
     * @return PropertyInterface
     *
     * @throws SchemaException
     * @throws ReflectionException
     */
    public function process(string $propertyName, JsonSchema $propertySchema): PropertyInterface
    {
        $property = parent::process($propertyName, $propertySchema);

        $property->onResolve(function () use ($property, $propertyName, $propertySchema): void {
            foreach ($property->getValidators() as $validator) {
                $this->checks[] = $validator->getValidator()->getCheck();
            }

            $subProperties = $this->processSubProperties($propertyName, $propertySchema, $property);

            $processedSubProperties = 0;
            foreach ($subProperties as $subProperty) {
                $subProperty->onResolve(function () use ($property, $subProperties, &$processedSubProperties) {
                    if (++$processedSubProperties === count($subProperties)) {
                        if (empty($this->allowedPropertyTypes)) {
                            return;
                        }

                        $property->addTypeHintDecorator(
                            new TypeHintDecorator(
                                array_map(
                                    static function (PropertyInterface $subProperty): string {
                                        return $subProperty->getTypeHint();
                                    },
                                    $subProperties
                                )
                            )
                        );

                        $property->addValidator(
                            new MultiTypeCheckValidator(
                                array_unique($this->allowedPropertyTypes),
                                $property,
                                $this->isImplicitNullAllowed($property)
                            ),
                            2
                        );
                    }
                });
            }
        });

        return $property;
    }

    /**
     * Move validators from the $source property to the $destination property
     *
     * @param PropertyInterface $source
     * @param PropertyInterface $destination
     */
    protected function transferValidators(PropertyInterface $source, PropertyInterface $destination)
    {
        foreach ($source->getValidators() as $validatorContainer) {
            $validator = $validatorContainer->getValidator();

            // filter out type checks to create a single type check which covers all allowed types
            if ($validator instanceof TypeCheckInterface) {
                array_push($this->allowedPropertyTypes, ...$validator->getTypes());

                continue;
            }

            // remove duplicated checks like an isset check
            if (in_array($validator->getCheck(), $this->checks)) {
                continue;
            }

            $destination->addValidator($validator, $validatorContainer->getPriority());
            $this->checks[] = $validator->getCheck();
        }
    }

    /**
     * @param string            $propertyName
     * @param JsonSchema        $propertySchema
     * @param PropertyInterface $property
     *
     * @return PropertyInterface[]
     *
     * @throws SchemaException
     */
    protected function processSubProperties(
        string $propertyName,
        JsonSchema $propertySchema,
        PropertyInterface $property
    ): array {
        $defaultValue = null;
        $invalidDefaultValueException = null;
        $invalidDefaultValues = 0;
        $subProperties = [];
        $json = $propertySchema->getJson();

        if (isset($json['default'])) {
            $defaultValue = $json['default'];
            unset($json['default']);
        }

        foreach ($this->propertyProcessors as $type => $propertyProcessor) {
            $json['type'] = $type;

            $subProperty = $propertyProcessor->process($propertyName, $propertySchema->withJson($json));

            $subProperty->onResolve(function () use ($property, $subProperty): void {
                $this->transferValidators($subProperty, $property);

                if ($subProperty->getDecorators()) {
                    $property->addDecorator(new PropertyTransferDecorator($subProperty));
                }
            });

            if ($defaultValue !== null && $propertyProcessor instanceof AbstractTypedValueProcessor) {
                try {
                    $propertyProcessor->setDefaultValue($property, $defaultValue, $propertySchema);
                } catch (SchemaException $e) {
                    $invalidDefaultValues++;
                    $invalidDefaultValueException = $e;
                }
            }

            $subProperties[] = $subProperty;
        }

        if ($invalidDefaultValues === count($this->propertyProcessors)) {
            throw $invalidDefaultValueException;
        }

        return $subProperties;
    }
}

1	<?php
2
3	declare(strict_types = 1);
4
5	namespace PHPModelGenerator\PropertyProcessor\Property;
6
7	use PHPModelGenerator\Exception\SchemaException;
8	use PHPModelGenerator\Model\Property\PropertyInterface;
9	use PHPModelGenerator\Model\Schema;
10	use PHPModelGenerator\Model\SchemaDefinition\JsonSchema;
11	use PHPModelGenerator\Model\Validator\MultiTypeCheckValidator;
12	use PHPModelGenerator\Model\Validator\TypeCheckInterface;
13	use PHPModelGenerator\PropertyProcessor\Decorator\Property\PropertyTransferDecorator;
14	use PHPModelGenerator\PropertyProcessor\Decorator\TypeHint\TypeHintDecorator;
15	use PHPModelGenerator\PropertyProcessor\PropertyMetaDataCollection;
16	use PHPModelGenerator\PropertyProcessor\PropertyProcessorFactory;
17	use PHPModelGenerator\PropertyProcessor\PropertyProcessorInterface;
18	use PHPModelGenerator\SchemaProcessor\SchemaProcessor;
19	use ReflectionException;
20
21	/**
22	* Class MultiTypePropertyProcessor
23	*
24	* @package PHPModelGenerator\PropertyProcessor\Property
25	*/
26	class MultiTypeProcessor extends AbstractValueProcessor
27	{
28	/** @var PropertyProcessorInterface[] */
29	protected $propertyProcessors = [];
30	/** @var string[] */
31	protected $allowedPropertyTypes = [];
32	/** @var string[] */
33	protected $checks = [];
34
35	/**
36	* MultiTypePropertyProcessor constructor.
37	*
38	* @param PropertyProcessorFactory $propertyProcessorFactory
39	* @param array $types
40	* @param PropertyMetaDataCollection $propertyMetaDataCollection
41	* @param SchemaProcessor $schemaProcessor
42	* @param Schema $schema
43	*
44	* @throws SchemaException
45	*/
46	public function __construct(
47	PropertyProcessorFactory $propertyProcessorFactory,
48	array $types,
49	PropertyMetaDataCollection $propertyMetaDataCollection,
50	SchemaProcessor $schemaProcessor,
51	Schema $schema
52	) {
53	parent::__construct($propertyMetaDataCollection, $schemaProcessor, $schema);	63✔
54
55	foreach ($types as $type) {	63✔
56	$this->propertyProcessors[$type] = $propertyProcessorFactory->getProcessor(	63✔
57	$type,	63✔
58	$propertyMetaDataCollection,	63✔
59	$schemaProcessor,	63✔
60	$schema	63✔
61	);	63✔
62	}
63	}
64
65	/**
66	* Process a property
67	*
68	* @param string $propertyName The name of the property
69	* @param JsonSchema $propertySchema The schema of the property
70	*
71	* @return PropertyInterface
72	*
73	* @throws SchemaException
74	* @throws ReflectionException
75	*/
76	public function process(string $propertyName, JsonSchema $propertySchema): PropertyInterface
77	{
78	$property = parent::process($propertyName, $propertySchema);	63✔
79
80	$property->onResolve(function () use ($property, $propertyName, $propertySchema): void {	62✔
81	foreach ($property->getValidators() as $validator) {	62✔
82	$this->checks[] = $validator->getValidator()->getCheck();	26✔
83	}
84
85	$subProperties = $this->processSubProperties($propertyName, $propertySchema, $property);	62✔
86
87	$processedSubProperties = 0;	59✔
88	foreach ($subProperties as $subProperty) {	59✔
89	$subProperty->onResolve(function () use ($property, $subProperties, &$processedSubProperties) {	59✔
90	if (++$processedSubProperties === count($subProperties)) {	59✔
91	if (empty($this->allowedPropertyTypes)) {	59✔
92	return;	×
93	}
94
95	$property->addTypeHintDecorator(	59✔
96	new TypeHintDecorator(	59✔
97	array_map(	59✔
98	static function (PropertyInterface $subProperty): string {	59✔
99	return $subProperty->getTypeHint();	59✔
100	},	59✔
101	$subProperties	59✔
102	)	59✔
103	)	59✔
104	);	59✔
105
106	$property->addValidator(	59✔
107	new MultiTypeCheckValidator(	59✔
108	array_unique($this->allowedPropertyTypes),	59✔
109	$property,	59✔
110	$this->isImplicitNullAllowed($property)	59✔
111	),	59✔
112	2	59✔
113	);	59✔
114	}
115	});	59✔
116	}
117	});	62✔
118
119	return $property;	59✔
120	}
121
122	/**
123	* Move validators from the $source property to the $destination property
124	*
125	* @param PropertyInterface $source
126	* @param PropertyInterface $destination
127	*/
128	protected function transferValidators(PropertyInterface $source, PropertyInterface $destination)
129	{
130	foreach ($source->getValidators() as $validatorContainer) {	62✔
131	$validator = $validatorContainer->getValidator();	62✔
132
133	// filter out type checks to create a single type check which covers all allowed types
134	if ($validator instanceof TypeCheckInterface) {	62✔
135	array_push($this->allowedPropertyTypes, ...$validator->getTypes());	62✔
136
137	continue;	62✔
138	}
139
140	// remove duplicated checks like an isset check
141	if (in_array($validator->getCheck(), $this->checks)) {	57✔
142	continue;	26✔
143	}
144
145	$destination->addValidator($validator, $validatorContainer->getPriority());	35✔
146	$this->checks[] = $validator->getCheck();	35✔
147	}
148	}
149
150	/**
151	* @param string $propertyName
152	* @param JsonSchema $propertySchema
153	* @param PropertyInterface $property
154	*
155	* @return PropertyInterface[]
156	*
157	* @throws SchemaException
158	*/
159	protected function processSubProperties(
160	string $propertyName,
161	JsonSchema $propertySchema,
162	PropertyInterface $property
163	): array {
164	$defaultValue = null;	62✔
165	$invalidDefaultValueException = null;	62✔
166	$invalidDefaultValues = 0;	62✔
167	$subProperties = [];	62✔
168	$json = $propertySchema->getJson();	62✔
169
170	if (isset($json['default'])) {	62✔
171	$defaultValue = $json['default'];	5✔
172	unset($json['default']);	5✔
173	}
174
175	foreach ($this->propertyProcessors as $type => $propertyProcessor) {	62✔
176	$json['type'] = $type;	62✔
177
178	$subProperty = $propertyProcessor->process($propertyName, $propertySchema->withJson($json));	62✔
179
180	$subProperty->onResolve(function () use ($property, $subProperty): void {	62✔
181	$this->transferValidators($subProperty, $property);	62✔
182
183	if ($subProperty->getDecorators()) {	62✔
184	$property->addDecorator(new PropertyTransferDecorator($subProperty));	32✔
185	}
186	});	62✔
187
188	if ($defaultValue !== null && $propertyProcessor instanceof AbstractTypedValueProcessor) {	62✔
189	try {
190	$propertyProcessor->setDefaultValue($property, $defaultValue, $propertySchema);	5✔
191	} catch (SchemaException $e) {	5✔
192	$invalidDefaultValues++;	5✔
193	$invalidDefaultValueException = $e;	5✔
194	}
195	}
196
197	$subProperties[] = $subProperty;	62✔
198	}
199
200	if ($invalidDefaultValues === count($this->propertyProcessors)) {	61✔
201	throw $invalidDefaultValueException;	2✔
202	}
203
204	return $subProperties;	59✔
205	}
206	}

wol-soft / php-json-schema-model-generator / 4564420247

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