Add support for php attributes (#1932)

* Add support for php attributes * Fix tests for php 8.1 * Simplify the annotations * Revert the changes to the tests * CS * Test FOSRest parsing of attributes * CS * typo * CS * Test fetchArticle php 8.1 attributes * Fix namespaces Co-authored-by: Guilhem Niot <guilhem@gniot.fr>
nelmio · Dec 21, 2021 · cc97b0b · cc97b0b
1 parent 3d263a5
commit cc97b0b
Show file tree

Hide file tree

Showing 19 changed files with 624 additions and 270 deletions.
diff --git a/.gitignore b/.gitignore
@@ -9,3 +9,4 @@
 /.phpunit.result.cache
 /Tests/Functional/cache
 /Tests/Functional/logs
+.idea
diff --git a/Annotation/Areas.php b/Annotation/Areas.php
@@ -14,6 +14,7 @@
 /**
  * @Annotation
  */
+#[\Attribute(\Attribute::TARGET_METHOD)]
 final class Areas
 {
     /** @var string[] */

diff --git a/Annotation/Model.php b/Annotation/Model.php
@@ -13,10 +13,12 @@
 
 use OpenApi\Annotations\AbstractAnnotation;
 use OpenApi\Annotations\Parameter;
+use OpenApi\Generator;
 
 /**
  * @Annotation
  */
+#[\Attribute(\Attribute::TARGET_METHOD)]
 final class Model extends AbstractAnnotation
 {
     /** {@inheritdoc} */
@@ -46,4 +48,22 @@ final class Model extends AbstractAnnotation
      * @var mixed[]
      */
     public $options;
+
+    /**
+     * @param mixed[]  $properties
+     * @param string[] $groups
+     * @param mixed[]  $options
+     */
+    public function __construct(
+        array $properties = [],
+        string $type = Generator::UNDEFINED,
+        array $groups = null,
+        array $options = null
+    ) {
+        parent::__construct($properties + [
+            'type' => $type,
+            'groups' => $groups,
+            'options' => $options,
+        ]);
+    }
 }
diff --git a/Annotation/Operation.php b/Annotation/Operation.php
@@ -16,6 +16,7 @@
 /**
  * @Annotation
  */
+#[\Attribute(\Attribute::TARGET_METHOD)]
 class Operation extends BaseOperation
 {
 }
diff --git a/Annotation/Security.php b/Annotation/Security.php
@@ -16,6 +16,7 @@
 /**
  * @Annotation
  */
+#[\Attribute(\Attribute::TARGET_CLASS | \Attribute::TARGET_METHOD | \Attribute::IS_REPEATABLE)]
 class Security extends AbstractAnnotation
 {
     /** {@inheritdoc} */
@@ -35,4 +36,15 @@ class Security extends AbstractAnnotation
      * @var string[]
      */
     public $scopes = [];
+
+    public function __construct(
+        array $properties = [],
+        string $name = null,
+        array $scopes = []
+    ) {
+        parent::__construct($properties + [
+            'name' => $name,
+            'scopes' => $scopes,
+        ]);
+    }
 }
diff --git a/Describer/OpenApiPhpDescriber.php b/Describer/OpenApiPhpDescriber.php
@@ -67,12 +67,14 @@ public function describe(OA\OpenApi $api)
                 $classAnnotations = array_filter($this->annotationReader->getClassAnnotations($declaringClass), function ($v) {
                     return $v instanceof OA\AbstractAnnotation;
                 });
+                $classAnnotations = array_merge($classAnnotations, $this->getAttributesAsAnnotation($declaringClass, OA\AbstractAnnotation::class));
                 $classAnnotations[$declaringClass->getName()] = $classAnnotations;
             }
 
             $annotations = array_filter($this->annotationReader->getMethodAnnotations($method), function ($v) {
                 return $v instanceof OA\AbstractAnnotation;
             });
+            $annotations = array_merge($annotations, $this->getAttributesAsAnnotation($method, OA\AbstractAnnotation::class));
 
             if (0 === count($annotations) && 0 === count($classAnnotations[$declaringClass->getName()])) {
                 continue;
@@ -190,4 +192,23 @@ private function normalizePath(string $path): string
 
         return $path;
     }
+
+    /**
+     * @param \ReflectionClass|\ReflectionMethod $reflection
+     *
+     * @return OA\AbstractAnnotation[]
+     */
+    private function getAttributesAsAnnotation($reflection, string $className): array
+    {
+        $annotations = [];
+        if (\PHP_VERSION_ID < 80100) {
+            return $annotations;
+        }
+
+        foreach ($reflection->getAttributes($className, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
+            $annotations[] = $attribute->newInstance();
+        }
+
+        return $annotations;
+    }
 }
diff --git a/ModelDescriber/Annotations/OpenApiAnnotationsReader.php b/ModelDescriber/Annotations/OpenApiAnnotationsReader.php
@@ -39,8 +39,8 @@ public function __construct(Reader $annotationsReader, ModelRegistry $modelRegis
 
     public function updateSchema(\ReflectionClass $reflectionClass, OA\Schema $schema): void
     {
-        /** @var OA\Schema $oaSchema */
-        if (!$oaSchema = $this->annotationsReader->getClassAnnotation($reflectionClass, OA\Schema::class)) {
+        /** @var OA\Schema|null $oaSchema */
+        if (!$oaSchema = $this->getAnnotation($reflectionClass, OA\Schema::class)) {
             return;
         }
 
@@ -56,10 +56,8 @@ public function updateSchema(\ReflectionClass $reflectionClass, OA\Schema $schem
 
     public function getPropertyName($reflection, string $default): string
     {
-        /** @var OA\Property $oaProperty */
-        if ($reflection instanceof \ReflectionProperty && !$oaProperty = $this->annotationsReader->getPropertyAnnotation($reflection, OA\Property::class)) {
-            return $default;
-        } elseif ($reflection instanceof \ReflectionMethod && !$oaProperty = $this->annotationsReader->getMethodAnnotation($reflection, OA\Property::class)) {
+        /** @var OA\Property|null $oaProperty */
+        if (!$oaProperty = $this->getAnnotation($reflection, OA\Property::class)) {
             return $default;
         }
 
@@ -78,10 +76,8 @@ public function updateProperty($reflection, OA\Property $property, array $serial
             'filename' => $declaringClass->getFileName(),
         ]));
 
-        /** @var OA\Property $oaProperty */
-        if ($reflection instanceof \ReflectionProperty && !$oaProperty = $this->annotationsReader->getPropertyAnnotation($reflection, OA\Property::class)) {
-            return;
-        } elseif ($reflection instanceof \ReflectionMethod && !$oaProperty = $this->annotationsReader->getMethodAnnotation($reflection, OA\Property::class)) {
+        /** @var OA\Property|null $oaProperty */
+        if (!$oaProperty = $this->getAnnotation($reflection, OA\Property::class)) {
             return;
         }
         $this->setContext(null);
@@ -95,4 +91,28 @@ public function updateProperty($reflection, OA\Property $property, array $serial
 
         $property->mergeProperties($oaProperty);
     }
+
+    /**
+     * @param \ReflectionClass|\ReflectionProperty|\ReflectionMethod $reflection
+     *
+     * @return mixed
+     */
+    private function getAnnotation($reflection, string $className)
+    {
+        if (\PHP_VERSION_ID >= 80100) {
+            if (null !== $attribute = $reflection->getAttributes($className, \ReflectionAttribute::IS_INSTANCEOF)[0] ?? null) {
+                return $attribute->newInstance();
+            }
+        }
+
+        if ($reflection instanceof \ReflectionClass) {
+            return $this->annotationsReader->getClassAnnotation($reflection, $className);
+        } elseif ($reflection instanceof \ReflectionProperty) {
+            return $this->annotationsReader->getPropertyAnnotation($reflection, $className);
+        } elseif ($reflection instanceof \ReflectionMethod) {
+            return $this->annotationsReader->getMethodAnnotation($reflection, $className);
+        }
+
+        return null;
+    }
 }
diff --git a/ModelDescriber/ObjectModelDescriber.php b/ModelDescriber/ObjectModelDescriber.php
@@ -72,7 +72,7 @@ public function describe(Model $model, OA\Schema $schema)
         $annotationsReader = new AnnotationsReader($this->doctrineReader, $this->modelRegistry, $this->mediaTypes);
         $annotationsReader->updateDefinition($reflClass, $schema);
 
-        $discriminatorMap = $this->doctrineReader->getClassAnnotation($reflClass, DiscriminatorMap::class);
+        $discriminatorMap = $this->getAnnotation($reflClass, DiscriminatorMap::class);
         if ($discriminatorMap && Generator::UNDEFINED === $schema->discriminator) {
             $this->applyOpenApiDiscriminator(
                 $model,
@@ -183,6 +183,20 @@ private function describeProperty(array $types, Model $model, OA\Schema $propert
         throw new \Exception(sprintf('Type "%s" is not supported in %s::$%s. You may use the `@OA\Property(type="")` annotation to specify it manually.', $types[0]->getBuiltinType(), $model->getType()->getClassName(), $propertyName));
     }
 
+    /**
+     * @return mixed
+     */
+    private function getAnnotation(\ReflectionClass $reflection, string $className)
+    {
+        if (\PHP_VERSION_ID >= 80000) {
+            if (null !== $attribute = $reflection->getAttributes($className, \ReflectionAttribute::IS_INSTANCEOF)[0] ?? null) {
+                return $attribute->newInstance();
+            }
+        }
+
+        return $this->doctrineReader->getClassAnnotation($reflection, $className);
+    }
+
     public function supports(Model $model): bool
     {
         return Type::BUILTIN_TYPE_OBJECT === $model->getType()->getBuiltinType() && class_exists($model->getType()->getClassName());

diff --git a/RouteDescriber/FosRestDescriber.php b/RouteDescriber/FosRestDescriber.php
@@ -44,6 +44,8 @@ public function describe(OA\OpenApi $api, Route $route, \ReflectionMethod $refle
         $annotations = array_filter($annotations, static function ($value) {
             return $value instanceof RequestParam || $value instanceof QueryParam;
         });
+        $annotations = array_merge($annotations, $this->getAttributesAsAnnotation($reflectionMethod, RequestParam::class));
+        $annotations = array_merge($annotations, $this->getAttributesAsAnnotation($reflectionMethod, QueryParam::class));
 
         foreach ($this->getOperations($api, $route) as $operation) {
             foreach ($annotations as $annotation) {
@@ -185,4 +187,21 @@ private function describeCommonSchemaFromAnnotation(OA\Schema $schema, $annotati
             $schema->format = $format;
         }
     }
+
+    /**
+     * @return OA\AbstractAnnotation[]
+     */
+    private function getAttributesAsAnnotation(\ReflectionMethod $reflection, string $className): array
+    {
+        $annotations = [];
+        if (\PHP_VERSION_ID < 80100) {
+            return $annotations;
+        }
+
+        foreach ($reflection->getAttributes($className, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
+            $annotations[] = $attribute->newInstance();
+        }
+
+        return $annotations;
+    }
 }
diff --git a/Routing/FilteredRouteCollectionBuilder.php b/Routing/FilteredRouteCollectionBuilder.php
@@ -130,13 +130,23 @@ private function matchAnnotation(Route $route): bool
         }
 
         /** @var Areas|null $areas */
-        $areas = $this->annotationReader->getMethodAnnotation(
-            $reflectionMethod,
-            Areas::class
-        );
+        $areas = $this->getAttributesAsAnnotation($reflectionMethod, Areas::class)[0] ?? null;
 
         if (null === $areas) {
-            $areas = $this->annotationReader->getClassAnnotation($reflectionMethod->getDeclaringClass(), Areas::class);
+            /** @var Areas|null $areas */
+            $areas = $this->getAttributesAsAnnotation($reflectionMethod->getDeclaringClass(), Areas::class)[0] ?? null;
+
+            if (null === $areas) {
+                /** @var Areas|null $areas */
+                $areas = $this->annotationReader->getMethodAnnotation(
+                    $reflectionMethod,
+                    Areas::class
+                );
+
+                if (null === $areas) {
+                    $areas = $this->annotationReader->getClassAnnotation($reflectionMethod->getDeclaringClass(), Areas::class);
+                }
+            }
         }
 
         return (null !== $areas) ? $areas->has($this->area) : false;
@@ -168,4 +178,23 @@ private function defaultRouteDisabled(Route $route): bool
 
         return false;
     }
+
+    /**
+     * @param \ReflectionClass|\ReflectionMethod $reflection
+     *
+     * @return Areas[]
+     */
+    private function getAttributesAsAnnotation($reflection, string $className): array
+    {
+        $annotations = [];
+        if (\PHP_VERSION_ID < 80100) {
+            return $annotations;
+        }
+
+        foreach ($reflection->getAttributes($className, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
+            $annotations[] = $attribute->newInstance();
+        }
+
+        return $annotations;
+    }
 }