Merge pull request #32 from sunrise-php/release/v1.10.0

sunrise-php · Sep 24, 2021 · 6b9158c · 6b9158c
2 parents b4d0244 + 6569723
commit 6b9158c
Show file tree

Hide file tree

Showing 7 changed files with 184 additions and 14 deletions.
diff --git a/src/AbstractAnnotation.php b/src/AbstractAnnotation.php
@@ -28,6 +28,11 @@
 abstract class AbstractAnnotation extends AbstractObject
 {
 
+    /**
+     * @var \ReflectionClass
+     */
+    public $_holder = null;
+
     /**
      * Recursively collects all annotations referenced by this object or its children
      *
@@ -44,7 +49,7 @@ public function getReferencedObjects(AnnotationReader $annotationReader) : array
             if ($value instanceof AbstractAnnotation) {
                 $objects = array_merge($objects, $value->getReferencedObjects($annotationReader));
             } elseif ($value instanceof AbstractAnnotationReference) {
-                $object = $value->getAnnotation($annotationReader);
+                $object = $value->getAnnotation($annotationReader, $this->_holder);
                 $objects[] = $object;
 
                 if ($object instanceof AbstractAnnotation) {

diff --git a/src/AbstractAnnotationReference.php b/src/AbstractAnnotationReference.php
@@ -95,13 +95,28 @@ abstract public function getAnnotationName() : string;
      * Tries to find a referenced object that implements the `ComponentObjectInterface` interface
      *
      * @param AnnotationReader $annotationReader
+     * @param ReflectionClass $holder
      *
      * @return ComponentObjectInterface
      *
      * @throws InvalidReferenceException
      */
-    public function getAnnotation(AnnotationReader $annotationReader) : ComponentObjectInterface
+    public function getAnnotation(AnnotationReader $annotationReader, ReflectionClass $holder = null) : ComponentObjectInterface
     {
+        if (false !== \strpos($this->class, '.')) {
+            list($this->class, $this->property) = \explode('.', $this->class, 2);
+        } elseif (false !== \strpos($this->class, '@')) {
+            list($this->class, $this->method) = \explode('@', $this->class, 2);
+        }
+
+        if (isset($holder)) {
+            if ('' === $this->class) {
+                $this->class = $holder->getName();
+            } elseif (false === \strpos($this->class, '\\') && $holder->getNamespaceName()) {
+                $this->class = $holder->getNamespaceName() . '\\' . $this->class;
+            }
+        }
+
         $key = hash(
             'md5',
             $this->class .
@@ -147,10 +162,9 @@ private function getMethodAnnotation(AnnotationReader $annotationReader) : Compo
             );
         }
 
-        $object = $annotationReader->getMethodAnnotation(
-            new ReflectionMethod($this->class, $this->method),
-            $this->getAnnotationName()
-        );
+        $reflection = new ReflectionMethod($this->class, $this->method);
+
+        $object = $annotationReader->getMethodAnnotation($reflection, $this->getAnnotationName());
 
         if (null === $object) {
             $message = 'Method %s::%s() does not contain the annotation %s';
@@ -159,6 +173,12 @@ private function getMethodAnnotation(AnnotationReader $annotationReader) : Compo
             );
         }
 
+        $object->_holder = $reflection->getDeclaringClass();
+
+        if (null === $object->refName) {
+            $object->refName = $reflection->getDeclaringClass()->getShortName() . '.fn_' . $reflection->getName();
+        }
+
         return $object;
     }
 
@@ -182,10 +202,9 @@ private function getPropertyAnnotation(AnnotationReader $annotationReader) : Com
             );
         }
 
-        $object = $annotationReader->getPropertyAnnotation(
-            new ReflectionProperty($this->class, $this->property),
-            $this->getAnnotationName()
-        );
+        $reflection = new ReflectionProperty($this->class, $this->property);
+
+        $object = $annotationReader->getPropertyAnnotation($reflection, $this->getAnnotationName());
 
         if (null === $object) {
             $message = 'Property %s::$%s does not contain the annotation %s';
@@ -194,6 +213,12 @@ private function getPropertyAnnotation(AnnotationReader $annotationReader) : Com
             );
         }
 
+        $object->_holder = $reflection->getDeclaringClass();
+
+        if (null === $object->refName) {
+            $object->refName = $reflection->getDeclaringClass()->getShortName() . '.' . $reflection->getName();
+        }
+
         return $object;
     }
 
@@ -217,10 +242,9 @@ private function getClassAnnotation(AnnotationReader $annotationReader) : Compon
             );
         }
 
-        $object = $annotationReader->getClassAnnotation(
-            new ReflectionClass($this->class),
-            $this->getAnnotationName()
-        );
+        $reflection = new ReflectionClass($this->class);
+
+        $object = $annotationReader->getClassAnnotation($reflection, $this->getAnnotationName());
 
         if (null === $object) {
             $message = 'Class %s does not contain the annotation %s';
@@ -229,6 +253,12 @@ private function getClassAnnotation(AnnotationReader $annotationReader) : Compon
             );
         }
 
+        $object->_holder = $reflection;
+
+        if (null === $object->refName) {
+            $object->refName = $reflection->getShortName();
+        }
+
         return $object;
     }
 }
diff --git a/src/AbstractObject.php b/src/AbstractObject.php
@@ -67,6 +67,11 @@ protected function getFields() : array
         $fields = [];
 
         foreach ($this as $name => $value) {
+            // the internal field (property) should be ignored...
+            if ('_' === $name[0]) {
+                continue;
+            }
+
             // the field (property) doesn't matter or is NULL...
             if (null === $value) {
                 continue;

diff --git a/tests/AbstractAnnotationTest.php b/tests/AbstractAnnotationTest.php
@@ -80,4 +80,72 @@ public function getAnnotationName() : string
 
         ], reset($referencedObjects)->toArray());
     }
+
+    /**
+     * @return void
+     */
+    public function testSimplifiedReferencing() : void
+    {
+        $annotation = new class extends AbstractAnnotation
+        {
+            public $child;
+            public $reference;
+
+            public function __construct()
+            {
+                $this->child = clone $this;
+
+                $this->child->reference = new class extends AbstractAnnotationReference
+                {
+                    public $class = Fixture\SimplifiedReferencing\Foo::class;
+
+                    public function getAnnotationName() : string
+                    {
+                        return Schema::class;
+                    }
+                };
+            }
+        };
+
+        $referencedObjects = $annotation->getReferencedObjects($this->createSimpleAnnotationReader());
+        foreach ($referencedObjects as &$referencedObject) {
+            $referencedObject = $referencedObject->toArray();
+        }
+
+        $this->assertSame([
+            [
+                'properties' => [
+                    'bar' => [
+                        '$ref' => '#/components/schemas/Bar',
+                    ],
+                    'baz' => [
+                        '$ref' => '#/components/schemas/Baz',
+                    ],
+                ],
+                'type' => 'object',
+            ],
+            [
+                'properties' => [
+                    'value' => [
+                        '$ref' => '#/components/schemas/Bar.value',
+                    ],
+                ],
+                'type' => 'object',
+            ],
+            [
+                'type' => 'string',
+            ],
+            [
+                'properties' => [
+                    'value' => [
+                        '$ref' => '#/components/schemas/Baz.fn_value',
+                    ],
+                ],
+                'type' => 'object',
+            ],
+            [
+                'type' => 'string',
+            ],
+        ], $referencedObjects);
+    }
 }
diff --git a/tests/Fixture/SimplifiedReferencing/Bar.php b/tests/Fixture/SimplifiedReferencing/Bar.php
@@ -0,0 +1,22 @@
+<?php declare(strict_types=1);
+
+namespace Sunrise\Http\Router\OpenApi\Tests\Fixture\SimplifiedReferencing;
+
+/**
+ * @OpenApi\Schema(
+ *     type="object",
+ *     properties={
+ *         "value": @OpenApi\SchemaReference(".value"),
+ *     },
+ * )
+ */
+class Bar
+{
+
+    /**
+     * @OpenApi\Schema(
+     *     type="string",
+     * )
+     */
+    public $value;
+}
diff --git a/tests/Fixture/SimplifiedReferencing/Baz.php b/tests/Fixture/SimplifiedReferencing/Baz.php
@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+
+namespace Sunrise\Http\Router\OpenApi\Tests\Fixture\SimplifiedReferencing;
+
+/**
+ * @OpenApi\Schema(
+ *     type="object",
+ *     properties={
+ *         "value": @OpenApi\SchemaReference("@value"),
+ *     },
+ * )
+ */
+class Baz
+{
+
+    /**
+     * @OpenApi\Schema(
+     *     type="string",
+     * )
+     */
+    public function value()
+    {
+    }
+}
diff --git a/tests/Fixture/SimplifiedReferencing/Foo.php b/tests/Fixture/SimplifiedReferencing/Foo.php
@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+namespace Sunrise\Http\Router\OpenApi\Tests\Fixture\SimplifiedReferencing;
+
+/**
+ * @OpenApi\Schema(
+ *     type="object",
+ *     properties={
+ *         "bar": @OpenApi\SchemaReference("Bar"),
+ *         "baz": @OpenApi\SchemaReference("Baz"),
+ *     },
+ * )
+ */
+class Foo
+{
+}