ComposedValueProcessors

Author: wol-soft

src/Model/Property/Property.php

@@ -96,6 +96,14 @@ public function getValidators(): array
         return $this->validator;
     }
 
+    /**
+     * @inheritdoc
+     */
+    public function filterValidators(callable $filter): void
+    {
+        $this->validator = array_filter($this->validator, $filter);
+    }
+
     /**
      * @inheritdoc
      */

src/Model/Property/PropertyInterface.php

@@ -52,6 +52,13 @@ public function addValidator(PropertyValidatorInterface $validator, int $priorit
      */
     public function getValidators(): array;
 
+    /**
+     * Filter the assigned validators
+     *
+     * @param callable $filter
+     */
+    public function filterValidators(callable $filter): void;
+
     /**
      * Retrieve all added validators ordered by priority
      *

src/Model/Property/PropertyProxy.php

@@ -90,6 +90,14 @@ public function getValidators(): array
         return $this->getProperty()->getValidators();
     }
 
+    /**
+     * @inheritdoc
+     */
+    public function filterValidators(callable $filter): void
+    {
+        $this->getProperty()->filterValidators($filter);
+    }
+
     /**
      * @inheritdoc
      */

src/Model/SchemaDefinition.php

@@ -10,6 +10,7 @@
 use PHPModelGenerator\Model\Property\PropertyProxy;
 use PHPModelGenerator\PropertyProcessor\PropertyCollectionProcessor;
 use PHPModelGenerator\PropertyProcessor\PropertyFactory;
+use PHPModelGenerator\PropertyProcessor\PropertyProcessorFactory;
 use PHPModelGenerator\SchemaProcessor\SchemaProcessor;
 
 /**
@@ -49,16 +50,20 @@ public function __construct(array $structure, SchemaProcessor $schemaProcessor,
     /**
      * Resolve a reference
      *
-     * @param string $propertyName
-     * @param array $path
+     * @param string                      $propertyName
+     * @param array                       $path
+     * @param PropertyCollectionProcessor $propertyCollectionProcessor
      *
      * @return PropertyInterface
      *
      * @throws PHPModelGeneratorException
      * @throws SchemaException
      */
-    public function resolveReference(string $propertyName, array $path): PropertyInterface
-    {
+    public function resolveReference(
+        string $propertyName,
+        array $path,
+        PropertyCollectionProcessor $propertyCollectionProcessor
+    ): PropertyInterface {
         $structure = $this->structure;
         while ($segment = array_shift($path)) {
             if (!isset($structure[$segment])) {
@@ -75,9 +80,9 @@ public function resolveReference(string $propertyName, array $path): PropertyInt
             // to the currently created property
             $this->resolvedPaths->offsetSet($key, true);
             try {
-                $this->resolvedPaths->offsetSet($key, (new PropertyFactory())
+                $this->resolvedPaths->offsetSet($key, (new PropertyFactory(new PropertyProcessorFactory()))
                     ->create(
-                        new PropertyCollectionProcessor(),
+                        $propertyCollectionProcessor,
                         $this->schemaProcessor,
                         $this->schema,
                         $propertyName,

src/Model/Validator/RequiredPropertyValidator.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace PHPModelGenerator\Model\Validator;
+
+use PHPModelGenerator\Exception\InvalidArgumentException;
+use PHPModelGenerator\Model\Property\PropertyInterface;
+
+/**
+ * Class RequiredPropertyValidator
+ *
+ * @package PHPModelGenerator\Model\Validator
+ */
+class RequiredPropertyValidator extends PropertyValidator
+{
+    /**
+     * RequiredPropertyValidator constructor.
+     *
+     * @param PropertyInterface $property
+     */
+    public function __construct(PropertyInterface $property)
+    {
+        parent::__construct(
+            "!isset(\$modelData['{$property->getName()}'])",
+            InvalidArgumentException::class,
+            "Missing required value for {$property->getName()}"
+        );
+    }
+}

src/PropertyProcessor/ComposedValue/AbstractComposedValueProcessor.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace PHPModelGenerator\PropertyProcessor\ComposedValue;
+
+use PHPModelGenerator\Exception\InvalidArgumentException;
+use PHPModelGenerator\Model\Property\PropertyInterface;
+use PHPModelGenerator\Model\Validator;
+use PHPModelGenerator\Model\Validator\PropertyTemplateValidator;
+use PHPModelGenerator\Model\Validator\RequiredPropertyValidator;
+use PHPModelGenerator\PropertyProcessor\Property\AbstractTypedValueProcessor;
+use PHPModelGenerator\PropertyProcessor\PropertyCollectionProcessor;
+use PHPModelGenerator\PropertyProcessor\PropertyFactory;
+use PHPModelGenerator\PropertyProcessor\PropertyProcessorFactory;
+use PHPModelGenerator\Utils\RenderHelper;
+
+/**
+ * Class AbstractComposedValueProcessor
+ *
+ * @package PHPModelGenerator\PropertyProcessor\ComposedValue
+ */
+abstract class AbstractComposedValueProcessor extends AbstractTypedValueProcessor
+{
+    /**
+     * @inheritdoc
+     */
+    protected function generateValidators(PropertyInterface $property, array $propertyData): void
+    {
+        $propertyFactory = new PropertyFactory(new PropertyProcessorFactory());
+
+        $properties = [];
+        foreach ($propertyData['composition'] as $compositionElement) {
+            $compositionProperty = $propertyFactory
+                ->create(
+                    new PropertyCollectionProcessor([$property->getName() => $property->isRequired()]),
+                    $this->schemaProcessor,
+                    $this->schema,
+                    $property->getName(),
+                    $compositionElement
+                );
+
+            $compositionProperty->filterValidators(function (Validator $validator) {
+                return !is_a($validator->getValidator(), RequiredPropertyValidator::class);
+            });
+
+            $properties[] = $compositionProperty;
+        }
+
+        $availableAmount = count($properties);
+
+        $property->addValidator(
+            new PropertyTemplateValidator(
+                InvalidArgumentException::class,
+                "Invalid value for {$property->getName()} declined by composition constraint",
+                DIRECTORY_SEPARATOR . 'Validator' . DIRECTORY_SEPARATOR . 'ComposedItem.phptpl',
+                [
+                    'properties' => $properties,
+                    'viewHelper' => new RenderHelper(),
+                    'availableAmount' => $availableAmount,
+                    'composedValueValidation' => $this->getComposedValueValidation($availableAmount),
+                ]
+            ),
+            100
+        );
+    }
+
+    /**
+     * @param int $composedElements The amount of elements which are composed together
+     *
+     * @return string
+     */
+    abstract function getComposedValueValidation(int $composedElements): string;
+}

src/PropertyProcessor/ComposedValue/AllOfProcessor.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace PHPModelGenerator\PropertyProcessor\ComposedValue;
+
+/**
+ * Class AllofProcessor
+ *
+ * @package PHPModelGenerator\PropertyProcessor\ComposedValue
+ */
+class AllOfProcessor extends AbstractComposedValueProcessor
+{
+    /**
+     * @inheritdoc
+     */
+    function getComposedValueValidation(int $composedElements): string
+    {
+        return "\$succeededCompositionElements === $composedElements";
+    }
+}

src/PropertyProcessor/ComposedValue/AnyOfProcessor.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace PHPModelGenerator\PropertyProcessor\ComposedValue;
+
+/**
+ * Class AnyofProcessor
+ *
+ * @package PHPModelGenerator\PropertyProcessor\ComposedValue
+ */
+class AnyOfProcessor extends AbstractComposedValueProcessor
+{
+    /**
+     * @inheritdoc
+     */
+    function getComposedValueValidation(int $composedElements): string
+    {
+        return "\$succeededCompositionElements > 0";
+    }
+}

src/PropertyProcessor/ComposedValue/NotProcessor.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PHPModelGenerator\PropertyProcessor\ComposedValue;
+
+use PHPModelGenerator\Model\Property\PropertyInterface;
+
+/**
+ * Class NotProcessor
+ *
+ * @package PHPModelGenerator\PropertyProcessor\ComposedValue
+ */
+class NotProcessor extends AbstractComposedValueProcessor
+{
+    /**
+     * @inheritdoc
+     */
+    protected function generateValidators(PropertyInterface $property, array $propertyData): void
+    {
+        // as the not composition only takes one schema nest it one level deeper to use the ComposedValueProcessor
+        $propertyData['composition'] = [$propertyData['composition']];
+        // strict type checks for not constraint to avoid issues with null
+        $property->setRequired(true);
+        parent::generateValidators($property, $propertyData);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    function getComposedValueValidation(int $composedElements): string
+    {
+        return '$succeededCompositionElements === 0';
+    }
+}

src/PropertyProcessor/ComposedValue/OneOfProcessor.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace PHPModelGenerator\PropertyProcessor\ComposedValue;
+
+/**
+ * Class OneofProcessor
+ *
+ * @package PHPModelGenerator\PropertyProcessor\ComposedValue
+ */
+class OneOfProcessor extends AbstractComposedValueProcessor
+{
+    /**
+     * @inheritdoc
+     */
+    function getComposedValueValidation(int $composedElements): string
+    {
+        return '$succeededCompositionElements === 1';
+    }
+}