17860521157

Committed 19 Sep 2025 02:01PM UTC coverage: 98.607%. First build

Build # 17860521157

Build Type

Pull #92

github

Committed by

wol-soft

Commit Message

remove unnecessary code

Pull Request Pull Request #92: BuilderClassPostProcessor

Run Details

144 of 146 new or added lines in 11 files covered. (98.63%)

3399 of 3447 relevant lines covered (98.61%)

566.07 hits per line

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

96.88

/src/SchemaProcessor/PostProcessor/BuilderClassPostProcessor.php

<?php

declare(strict_types = 1);

namespace PHPModelGenerator\SchemaProcessor\PostProcessor;

use PHPMicroTemplate\Render;
use PHPModelGenerator\Exception\FileSystemException;
use PHPModelGenerator\Exception\ValidationException;
use PHPModelGenerator\Interfaces\BuilderInterface;
use PHPModelGenerator\Interfaces\JSONModelInterface;
use PHPModelGenerator\Model\GeneratorConfiguration;
use PHPModelGenerator\Model\Property\PropertyInterface;
use PHPModelGenerator\Model\Property\PropertyType;
use PHPModelGenerator\Model\Schema;
use PHPModelGenerator\Model\Validator;
use PHPModelGenerator\PropertyProcessor\Decorator\TypeHint\TypeHintDecorator;
use PHPModelGenerator\PropertyProcessor\Decorator\TypeHint\TypeHintTransferDecorator;
use PHPModelGenerator\Utils\RenderHelper;
use UnitEnum;

class BuilderClassPostProcessor extends PostProcessor
{
    /** @var Schema[] */
    private array $schemas = [];
    private ?GeneratorConfiguration $generatorConfiguration;
    private ?RenderHelper $renderHelper;

    public function process(Schema $schema, GeneratorConfiguration $generatorConfiguration): void
    {
        // collect the schemas and generate builder classes in postProcess hook to make sure the related model class
        // already has been created
        $this->schemas[] = $schema;
        $this->generatorConfiguration ??= $generatorConfiguration;
        $this->renderHelper ??= new RenderHelper($generatorConfiguration);
    }

    public function preProcess(): void
    {
        $this->generatorConfiguration = null;
        $this->renderHelper = null;
    }

    public function postProcess(): void
    {
        parent::postProcess();

        foreach ($this->schemas as $schema) {
            $properties = [];
            foreach ($schema->getProperties() as $property) {
                if (!$property->isInternal()) {
                    $properties[] = (clone $property)
                        ->setReadOnly(false)
                        ->addTypeHintDecorator(new TypeHintTransferDecorator($property))
                        ->filterValidators(static fn(Validator $validator): bool => false);
                }
            }

            $namespace = trim(
                join('\\', [$this->generatorConfiguration->getNamespacePrefix(), $schema->getClassPath()]),
                '\\',
            );

            $result = file_put_contents(
                $filename = str_replace('.php', 'Builder.php', $schema->getTargetFileName()),
                (new Render(__DIR__ . DIRECTORY_SEPARATOR . 'Templates' . DIRECTORY_SEPARATOR))->renderTemplate(
                    'BuilderClass.phptpl',
                    [
                        'namespace'              => $namespace,
                        'class'                  => $schema->getClassName(),
                        'schema'                 => $schema,
                        'properties'             => $properties,
                        'use'                    => $this->getBuilderClassImports($properties, $schema->getUsedClasses(), $namespace),
                        'generatorConfiguration' => $this->generatorConfiguration,
                        'viewHelper'             => new RenderHelper($this->generatorConfiguration),
                    ],
                )
            );

            $fqcn = "$namespace\\{$schema->getClassName()}Builder";

            if ($result === false) {
                // @codeCoverageIgnoreStart
                throw new FileSystemException("Can't write builder class $fqcn.",);
                // @codeCoverageIgnoreEnd
            }

            require $filename;

            if ($this->generatorConfiguration->isOutputEnabled()) {
                // @codeCoverageIgnoreStart
                echo "Rendered builder class $fqcn\n";
                // @codeCoverageIgnoreEnd
            }
        }
    }

    /**
     * @param PropertyInterface[] $properties
     *
     * @return string[]
     */
    private function getBuilderClassImports(array $properties, array $originalClassImports, string $namespace): array
    {
        $imports = [BuilderInterface::class];
        $imports[] = $this->generatorConfiguration->collectErrors()
            ? $this->generatorConfiguration->getErrorRegistryClass()
            : ValidationException::class;

        foreach ($properties as $property) {
            // use typehint instead of type to cover multi-types
            foreach (array_unique([
                ...explode('|', $this->renderHelper->getTypeHintAnnotation($property)),
                ...explode('|', $this->renderHelper->getTypeHintAnnotation($property, true)),
            ]) as $typeAnnotation) {
                $type = str_replace('[]', '', $typeAnnotation);

                // as the typehint only knows the class name but not the fqcn, lookup in the original imports
                foreach ($originalClassImports as $originalClassImport) {
                    if (str_ends_with($originalClassImport, "\\$type")) {
                        $type = $originalClassImport;
                    }
                }

                // required for compatibility with the EnumPostProcessor
                if (enum_exists($type)) {
                    array_push($imports, $type, UnitEnum::class);
                }

                if (class_exists($type)) {
                    $imports[] = $type;

                    // for nested objects, allow additionally to pass an instance of the nested model also just plain
                    // arrays which will result in an object instantiation and validation during the build process
                    if (in_array(JSONModelInterface::class, class_implements($type))) {
                        $property->addTypeHintDecorator(new TypeHintDecorator(
                            [basename($type) . 'Builder' . (str_contains($typeAnnotation, '[]') ? '[]' : ''), 'array'],
                        ));

                        $property->setType();
                    }
                }
            }
        }

        return RenderHelper::filterClassImports(array_unique($imports), $namespace);
    }
}

1	<?php
2
3	declare(strict_types = 1);
4
5	namespace PHPModelGenerator\SchemaProcessor\PostProcessor;
6
7	use PHPMicroTemplate\Render;
8	use PHPModelGenerator\Exception\FileSystemException;
9	use PHPModelGenerator\Exception\ValidationException;
10	use PHPModelGenerator\Interfaces\BuilderInterface;
11	use PHPModelGenerator\Interfaces\JSONModelInterface;
12	use PHPModelGenerator\Model\GeneratorConfiguration;
13	use PHPModelGenerator\Model\Property\PropertyInterface;
14	use PHPModelGenerator\Model\Property\PropertyType;
15	use PHPModelGenerator\Model\Schema;
16	use PHPModelGenerator\Model\Validator;
17	use PHPModelGenerator\PropertyProcessor\Decorator\TypeHint\TypeHintDecorator;
18	use PHPModelGenerator\PropertyProcessor\Decorator\TypeHint\TypeHintTransferDecorator;
19	use PHPModelGenerator\Utils\RenderHelper;
20	use UnitEnum;
21
22	class BuilderClassPostProcessor extends PostProcessor
23	{
24	/** @var Schema[] */
25	private array $schemas = [];
26	private ?GeneratorConfiguration $generatorConfiguration;
27	private ?RenderHelper $renderHelper;
28
29	public function process(Schema $schema, GeneratorConfiguration $generatorConfiguration): void	6✔
30	{
31	// collect the schemas and generate builder classes in postProcess hook to make sure the related model class
32	// already has been created
33	$this->schemas[] = $schema;	6✔
34	$this->generatorConfiguration ??= $generatorConfiguration;	6✔
35	$this->renderHelper ??= new RenderHelper($generatorConfiguration);	6✔
36	}
37
38	public function preProcess(): void	6✔
39	{
40	$this->generatorConfiguration = null;	6✔
41	$this->renderHelper = null;	6✔
42	}
43
44	public function postProcess(): void	6✔
45	{
46	parent::postProcess();	6✔
47
48	foreach ($this->schemas as $schema) {	6✔
49	$properties = [];	6✔
50	foreach ($schema->getProperties() as $property) {	6✔
51	if (!$property->isInternal()) {	6✔
52	$properties[] = (clone $property)	6✔
53	->setReadOnly(false)	6✔
54	->addTypeHintDecorator(new TypeHintTransferDecorator($property))	6✔
55	->filterValidators(static fn(Validator $validator): bool => false);	6✔
56	}
57	}
58
59	$namespace = trim(	6✔
60	join('\\', [$this->generatorConfiguration->getNamespacePrefix(), $schema->getClassPath()]),	6✔
61	'\\',	6✔
62	);	6✔
63
64	$result = file_put_contents(	6✔
65	$filename = str_replace('.php', 'Builder.php', $schema->getTargetFileName()),	6✔
66	(new Render(__DIR__ . DIRECTORY_SEPARATOR . 'Templates' . DIRECTORY_SEPARATOR))->renderTemplate(	6✔
67	'BuilderClass.phptpl',	6✔
68	[	6✔
69	'namespace' => $namespace,	6✔
70	'class' => $schema->getClassName(),	6✔
71	'schema' => $schema,	6✔
72	'properties' => $properties,	6✔
73	'use' => $this->getBuilderClassImports($properties, $schema->getUsedClasses(), $namespace),	6✔
74	'generatorConfiguration' => $this->generatorConfiguration,	6✔
75	'viewHelper' => new RenderHelper($this->generatorConfiguration),	6✔
76	],	6✔
77	)	6✔
78	);	6✔
79
80	$fqcn = "$namespace\\{$schema->getClassName()}Builder";	6✔
81
82	if ($result === false) {	6✔
83	// @codeCoverageIgnoreStart
84	throw new FileSystemException("Can't write builder class $fqcn.",);
85	// @codeCoverageIgnoreEnd
86	}
87
88	require $filename;	6✔
89
90	if ($this->generatorConfiguration->isOutputEnabled()) {	6✔
91	// @codeCoverageIgnoreStart
92	echo "Rendered builder class $fqcn\n";
93	// @codeCoverageIgnoreEnd
94	}
95	}
96	}
97
98	/**
99	* @param PropertyInterface[] $properties
100	*
101	* @return string[]
102	*/
103	private function getBuilderClassImports(array $properties, array $originalClassImports, string $namespace): array	6✔
104	{
105	$imports = [BuilderInterface::class];	6✔
106	$imports[] = $this->generatorConfiguration->collectErrors()	6✔
107	? $this->generatorConfiguration->getErrorRegistryClass()	2✔
108	: ValidationException::class;	4✔
109
110	foreach ($properties as $property) {	6✔
111	// use typehint instead of type to cover multi-types
112	foreach (array_unique([	6✔
113	...explode('\|', $this->renderHelper->getTypeHintAnnotation($property)),	6✔
114	...explode('\|', $this->renderHelper->getTypeHintAnnotation($property, true)),	6✔
115	]) as $typeAnnotation) {	6✔
116	$type = str_replace('[]', '', $typeAnnotation);	6✔
117
118	// as the typehint only knows the class name but not the fqcn, lookup in the original imports
119	foreach ($originalClassImports as $originalClassImport) {	6✔
120	if (str_ends_with($originalClassImport, "\\$type")) {	6✔
NEW 121	$type = $originalClassImport;	×
122	}
123	}
124
125	// required for compatibility with the EnumPostProcessor
126	if (enum_exists($type)) {	6✔
NEW 127	array_push($imports, $type, UnitEnum::class);	×
128	}
129
130	if (class_exists($type)) {	6✔
131	$imports[] = $type;	2✔
132
133	// for nested objects, allow additionally to pass an instance of the nested model also just plain
134	// arrays which will result in an object instantiation and validation during the build process
135	if (in_array(JSONModelInterface::class, class_implements($type))) {	2✔
136	$property->addTypeHintDecorator(new TypeHintDecorator(	2✔
137	[basename($type) . 'Builder' . (str_contains($typeAnnotation, '[]') ? '[]' : ''), 'array'],	2✔
138	));	2✔
139
140	$property->setType();	2✔
141	}
142	}
143	}
144	}
145
146	return RenderHelper::filterClassImports(array_unique($imports), $namespace);	6✔
147	}
148	}

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

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