Merge pull request #32 from rebuy-de/support-max-depth

Add support for max-depth

Author: dbu

CHANGELOG.md

@@ -5,6 +5,7 @@
 * When running with PHP 8, process attributes in addition to the phpdoc annotations.
 * Support doctrine collections
 * Support `identical` property naming strategy
+* Add support for the `MaxDepth` annotation from JMS
 
 # 0.5.0
 

README.md

@@ -130,6 +130,29 @@ class Product
 
 ### Expected Recursion: Working with Flawed Models
 
+#### JMS annotation
+
+If you are using JMS annotations, you can add the `MaxDepth` annotation to 
+properties that might be recursive. 
+
+The following example will tell the metadata parser that the recursion is 
+expected up to a maximum depth of `3`.
+
+```php
+use JMS\Serializer\Annotation as JMS;
+
+class RecursionModel 
+{
+    /**
+     * @JMS\MaxDepth(3)
+     * @JMS\Type("RecursionModel")
+     */
+    public $recursion;
+}
+```
+
+#### Pure PHP 
+
 The RecursionChecker accepts a second parameter to specify places where to
 break recursion. This is useful if your model tree looks like it has recursions
 but actually does not have them. JMSSerializer always acts on the actual data

src/Metadata/AbstractPropertyMetadata.php

@@ -39,6 +39,11 @@ abstract class AbstractPropertyMetadata implements \JsonSerializable
      */
     private $versionRange;
 
+    /**
+     * @var int|null
+     */
+    private $maxDepth = null;
+
     /**
      * Hashmap of custom information about this property.
      *
@@ -133,6 +138,7 @@ public function jsonSerialize(): array
             'name' => $this->name,
             'is_public' => $this->public,
             'is_read_only' => $this->readOnly,
+            'max_depth' => $this->maxDepth,
         ];
 
         if (\count($this->groups) > 0) {
@@ -194,4 +200,14 @@ protected function setCustomInformation(string $key, $value): void
     {
         $this->customInformation[$key] = $value;
     }
+
+    protected function getMaxDepth(): ?int
+    {
+        return $this->maxDepth;
+    }
+
+    protected function setMaxDepth(?int $maxDepth)
+    {
+        $this->maxDepth = $maxDepth;
+    }
 }

src/Metadata/PropertyMetadata.php

@@ -31,7 +31,8 @@ public function __construct(
         VersionRange $versionRange = null,
         array $groups = [],
         PropertyAccessor $accessor = null,
-        array $customInformation = []
+        array $customInformation = [],
+        ?int $maxDepth = null
     ) {
         parent::__construct($name, $readOnly, $public);
         $this->serializedName = $serializedName;
@@ -44,6 +45,8 @@ public function __construct(
         foreach ($customInformation as $key => $value) {
             $this->setCustomInformation((string) $key, $value);
         }
+
+        $this->setMaxDepth($maxDepth);
     }
 
     public function __toString(): string
@@ -62,7 +65,8 @@ public static function fromRawProperty(string $serializedName, PropertyVariation
             $property->getVersionRange(),
             $property->getGroups(),
             $property->getAccessor(),
-            $property->getAllCustomInformation()
+            $property->getAllCustomInformation(),
+            $property->getMaxDepth()
         );
     }
 
@@ -76,6 +80,11 @@ public function getSerializedName(): string
         return $this->serializedName;
     }
 
+    public function getMaxDepth(): ?int
+    {
+        return parent::getMaxDepth();
+    }
+
     public function jsonSerialize(): array
     {
         return array_merge(

src/ModelParser/JMSParser.php

@@ -18,6 +18,7 @@
 use JMS\Serializer\Annotation\Exclude;
 use JMS\Serializer\Annotation\ExclusionPolicy;
 use JMS\Serializer\Annotation\Groups;
+use JMS\Serializer\Annotation\MaxDepth;
 use JMS\Serializer\Annotation\PostDeserialize;
 use JMS\Serializer\Annotation\SerializedName;
 use JMS\Serializer\Annotation\Since;
@@ -291,6 +292,10 @@ private function parsePropertyAnnotations(RawClassMetadata $classMetadata, Prope
                     $property->setVersionRange($property->getVersionRange()->withUntil($annotation->version));
                     break;
 
+                case $annotation instanceof MaxDepth:
+                    $property->setMaxDepth($annotation->depth);
+                    break;
+
                 case $annotation instanceof VirtualProperty:
                     // we handle this separately
                 case $annotation instanceof SerializedName:

src/ModelParser/RawMetadata/PropertyVariationMetadata.php

@@ -87,6 +87,16 @@ public function setVersionRange(VersionRange $version): void
         parent::setVersionRange($version);
     }
 
+    public function getMaxDepth(): ?int
+    {
+        return parent::getMaxDepth();
+    }
+
+    public function setMaxDepth(?int $maxDepth)
+    {
+        parent::setMaxDepth($maxDepth);
+    }
+
     /**
      * The value can be anything that the consumer understands.
      *

src/RecursionChecker.php

@@ -96,14 +96,16 @@ private function checkClassMetadata(ClassMetadata $classMetadata, RecursionConte
                     }
                 }
 
-                /*
-                 * Future feature idea: Instead of 2, we could use a configurable maximum recursion depth.
-                 * One could then allow to unroll a recursion up to a certain number and stop it after that.
-                 */
-                if ($propertyContext->countClassNames($propertyClassMetadata->getClassName()) > 2) {
+                $maxDepth = $property->getMaxDepth();
+                $stackCount = $propertyContext->countClassNames($classMetadata->getClassName());
+                if (null === $maxDepth && $stackCount > 2) {
                     throw RecursionException::forClass($propertyClassMetadata->getClassName(), $propertyContext);
                 }
 
+                if (null !== $maxDepth && $stackCount > $maxDepth) {
+                    return $classMetadata;
+                }
+
                 $type->setClassMetadata($this->checkClassMetadata($propertyClassMetadata, $propertyContext));
             }
         }

tests/ModelParser/JMSParserTest.php

@@ -677,7 +677,7 @@ public function testUnsupportedPropertyAnnotations(): void
         $c = new class() {
             /**
              * @JMS\Type("string")
-             * @JMS\MaxDepth(1)
+             * @JMS\Inline()
              */
             private $property;
         };

tests/RecursionCheckerTest.php

@@ -59,6 +59,36 @@ public function testRecursion(): void
         $this->createChecker()->check($classMetadata);
     }
 
+    public function testRecursionWithMaxDepth(): void
+    {
+        $customClassType = new PropertyTypeClass(Recursion::class, true);
+        $classMetadata = new ClassMetadata(
+            Recursion::class,
+            [
+                new PropertyMetadata(
+                    'property',
+                    'property',
+                    $customClassType,
+                    true,
+                    false,
+                    null,
+                    [],
+                    null,
+                    [],
+                    2
+                ),
+            ]
+        );
+        $customClassType->setClassMetadata($classMetadata);
+
+        $metadata = $this->createChecker()->check($classMetadata);
+
+        /** @var PropertyTypeClass $type */
+        $type = $metadata->getProperties()[0]->getType();
+        $this->assertInstanceOf(PropertyTypeClass::class, $type);
+        $this->assertCount(1, $type->getClassMetadata()->getProperties());
+    }
+
     public function testRecursionOnArray(): void
     {
         $customClassType = new PropertyTypeClass(Recursion::class, true);