30306608636

Committed 27 Jul 2026 09:22PM UTC coverage: 98.599% (-0.1%) from 98.746%

Build # 30306608636

Build Type

Pull #178

github

Committed by

claude

Commit Message

Restructure dual-depth templates and migrate to php-micro-template's RenderConfig

Resolves the two remaining "dual-depth" template limitations by extracting
each shared body into its own sub-template, rendered via a nested
Render::renderTemplate() call and embedded with viewHelper.indent(): the
isMutableBaseValidator branch in ComposedItem.phptpl, and the
collectErrors(false) branch shared by SchemaDependency.phptpl and
Populate.phptpl. Pure rendering-mechanism change with no difference in the
generated PHP.

Migrates from the ad-hoc, locally-patched php-micro-template vendor copy to
the library's real RenderConfig/autoIndent feature, released as 1.12.0,
which is what the whole-suite phpcs formatting fixes in the prior commit
actually depend on for eliminating blank lines and getting correctly
indented, PSR-12-compliant generated code. Adds RenderFactory as the single
point of truth for constructing Render instances with autoIndent enabled,
caching by base path, replacing the per-class self::$renderer caching
that's now redundant.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PL4k3uwbW6xC2SjKNyjxFT

Pull Request Pull Request #178: Fix generated-code formatting bugs found via whole-suite phpcs audit

Coverage Stats

199 of 211 new or added lines in 23 files covered. (94.31%)

7176 of 7278 relevant lines covered (98.6%)

573.03 hits per line

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

81.25

/src/PropertyProcessor/Filter/FilterPreTransformGuardValidator.php

<?php

declare(strict_types=1);

namespace PHPModelGenerator\PropertyProcessor\Filter;

use PHPMicroTemplate\Exception\PHPMicroTemplateException;
use PHPModelGenerator\Exception\RenderException;
use PHPModelGenerator\Model\GeneratorConfiguration;
use PHPModelGenerator\Model\MethodInterface;
use PHPModelGenerator\Model\Property\PropertyInterface;
use PHPModelGenerator\Model\Schema;
use PHPModelGenerator\Model\Validator\AbstractComposedPropertyValidator;
use PHPModelGenerator\Model\Validator\ExtractedMethodValidator;
use PHPModelGenerator\Utils\RenderHelper;

/**
 * Wraps an input-space composition validator with a skip guard that bypasses the entire
 * composition check when the property value is already in the filter's output type-space.
 * Keeps filter-specific mechanics entirely within the filter package.
 */
final class FilterPreTransformGuardValidator extends ExtractedMethodValidator
{
    public function __construct(
        GeneratorConfiguration $generatorConfiguration,
        PropertyInterface $property,
        private readonly AbstractComposedPropertyValidator $inner,
        private readonly string $skipCheck,
    ) {
        parent::__construct($generatorConfiguration, $property, '', [], '', []);
        $this->extractedMethodName = 'filterPreTransformGuard_' . $inner->getExtractedMethodName();
        $this->isResolved = true;
    }

    /**
     * Sets scope on both this guard and the wrapped inner validator, and registers the
     * inner validator's extracted method in the schema.
     *
     * RenderHelper::renderValidator() processes only validators that are directly in the
     * property's validators list. The inner wrapped validator is not on that list, so
     * RenderHelper never registers its extracted method automatically. The guard method's
     * generated code calls $this->innerMethodName by name, which must exist as a class
     * method. This block registers it manually; the hasMethod check prevents
     * double-registration when setScope() is called more than once on the same guard.
     *
     * $this->inner->setScope($schema) sets the inner validator's $scope field so that
     * its getCheck() can reference $this->scope during template rendering.
     */
    public function setScope(Schema $schema): void
    {
        parent::setScope($schema);
        $this->inner->setScope($schema);

        if (!$schema->hasMethod($this->inner->getExtractedMethodName())) {
            $schema->addMethod($this->inner->getExtractedMethodName(), $this->inner->getMethod());
        }
    }

    /**
     * Returns the wrapped input-space composition validator.
     */
    public function getInnerValidator(): AbstractComposedPropertyValidator
    {
        return $this->inner;
    }

    /**
     * Returns a method that short-circuits when the value is already in the filter's
     * output type-space, and otherwise delegates to the wrapped composition validator.
     */
    public function getMethod(): MethodInterface
    {
        return new class ($this) implements MethodInterface {
            public function __construct(private readonly FilterPreTransformGuardValidator $validator)
            {}

            public function getCode(): string
            {
                return $this->validator->renderGuardMethod();
            }
        };
    }

    /**
     * @throws RenderException
     */
    public function renderGuardMethod(): string
    {
        try {
            return $this->getRenderer()->renderTemplate(
                DIRECTORY_SEPARATOR . 'Validator' . DIRECTORY_SEPARATOR . 'FilterPreTransformGuard.phptpl',
                [
                    'guardMethodName' => $this->getExtractedMethodName(),
                    'innerMethodName' => $this->inner->getExtractedMethodName(),
                    'skipCheck' => $this->skipCheck,
                    'viewHelper' => new RenderHelper($this->generatorConfiguration),
                ],
            );
        } catch (PHPMicroTemplateException $exception) {
            throw new RenderException(
                "Can't render filter pre-transform guard {$this->getExtractedMethodName()}",
                0,
                $exception,
            );
        }
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace PHPModelGenerator\PropertyProcessor\Filter;
6
7	use PHPMicroTemplate\Exception\PHPMicroTemplateException;
8	use PHPModelGenerator\Exception\RenderException;
9	use PHPModelGenerator\Model\GeneratorConfiguration;
10	use PHPModelGenerator\Model\MethodInterface;
11	use PHPModelGenerator\Model\Property\PropertyInterface;
12	use PHPModelGenerator\Model\Schema;
13	use PHPModelGenerator\Model\Validator\AbstractComposedPropertyValidator;
14	use PHPModelGenerator\Model\Validator\ExtractedMethodValidator;
15	use PHPModelGenerator\Utils\RenderHelper;
16
17	/**
18	* Wraps an input-space composition validator with a skip guard that bypasses the entire
19	* composition check when the property value is already in the filter's output type-space.
20	* Keeps filter-specific mechanics entirely within the filter package.
21	*/
22	final class FilterPreTransformGuardValidator extends ExtractedMethodValidator
23	{
24	public function __construct(	23✔
25	GeneratorConfiguration $generatorConfiguration,
26	PropertyInterface $property,
27	private readonly AbstractComposedPropertyValidator $inner,
28	private readonly string $skipCheck,
29	) {
30	parent::__construct($generatorConfiguration, $property, '', [], '', []);	23✔
31	$this->extractedMethodName = 'filterPreTransformGuard_' . $inner->getExtractedMethodName();	23✔
32	$this->isResolved = true;	23✔
33	}
34
35	/**
36	* Sets scope on both this guard and the wrapped inner validator, and registers the
37	* inner validator's extracted method in the schema.
38	*
39	* RenderHelper::renderValidator() processes only validators that are directly in the
40	* property's validators list. The inner wrapped validator is not on that list, so
41	* RenderHelper never registers its extracted method automatically. The guard method's
42	* generated code calls $this->innerMethodName by name, which must exist as a class
43	* method. This block registers it manually; the hasMethod check prevents
44	* double-registration when setScope() is called more than once on the same guard.
45	*
46	* $this->inner->setScope($schema) sets the inner validator's $scope field so that
47	* its getCheck() can reference $this->scope during template rendering.
48	*/
49	public function setScope(Schema $schema): void	23✔
50	{
51	parent::setScope($schema);	23✔
52	$this->inner->setScope($schema);	23✔
53
54	if (!$schema->hasMethod($this->inner->getExtractedMethodName())) {	23✔
55	$schema->addMethod($this->inner->getExtractedMethodName(), $this->inner->getMethod());	23✔
56	}
57	}
58
59	/**
60	* Returns the wrapped input-space composition validator.
61	*/
62	public function getInnerValidator(): AbstractComposedPropertyValidator	21✔
63	{
64	return $this->inner;	21✔
65	}
66
67	/**
68	* Returns a method that short-circuits when the value is already in the filter's
69	* output type-space, and otherwise delegates to the wrapped composition validator.
70	*/
71	public function getMethod(): MethodInterface	23✔
72	{
73	return new class ($this) implements MethodInterface {	23✔
74	public function __construct(private readonly FilterPreTransformGuardValidator $validator)
75	{}	23✔
76
77	public function getCode(): string
78	{
79	return $this->validator->renderGuardMethod();	23✔
80	}
81	};	23✔
82	}
83
84	/**
85	* @throws RenderException
86	*/
87	public function renderGuardMethod(): string	23✔
88	{
89	try {
90	return $this->getRenderer()->renderTemplate(	23✔
91	DIRECTORY_SEPARATOR . 'Validator' . DIRECTORY_SEPARATOR . 'FilterPreTransformGuard.phptpl',	23✔
92	[	23✔
93	'guardMethodName' => $this->getExtractedMethodName(),	23✔
94	'innerMethodName' => $this->inner->getExtractedMethodName(),	23✔
95	'skipCheck' => $this->skipCheck,	23✔
96	'viewHelper' => new RenderHelper($this->generatorConfiguration),	23✔
97	],	23✔
98	);	23✔
NEW 99	} catch (PHPMicroTemplateException $exception) {	×
NEW 100	throw new RenderException(	×
NEW 101	"Can't render filter pre-transform guard {$this->getExtractedMethodName()}",	×
NEW 102	0,	×
NEW 103	$exception,	×
NEW 104	);	×
105	}
106	}
107	}

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

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