vendor/friendsofsymfony/rest-bundle/Request/ParamReader.php line 54

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the FOSRestBundle package.
  5.  *
  6.  * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace FOS\RestBundle\Request;
  14. use Doctrine\Common\Annotations\Reader;
  15. use FOS\RestBundle\Controller\Annotations\ParamInterface;
  17. /**
  18.  * Class loading "@ParamInterface" annotations from methods.
  19.  *
  20.  * @author Alexander <iam.asm89@gmail.com>
  21.  * @author Lukas Kahwe Smith <smith@pooteeweet.org>
  22.  * @author Boris Guéry  <guery.b@gmail.com>
  23.  */
  24. final class ParamReader implements ParamReaderInterface
  25. {
  26.     /**
  27.      * @var Reader|null
  28.      */
  29.     private $annotationReader;
  31.     public function __construct(?Reader $annotationReader = null)
  32.     {
  33.         $this->annotationReader = $annotationReader;
  34.     }
  36.     /**
  37.      * {@inheritdoc}
  38.      */
  39.     public function read(\ReflectionClass $reflection, string $method): array
  40.     {
  41.         if (!$reflection->hasMethod($method)) {
  42.             throw new \InvalidArgumentException(sprintf('Class "%s" has no method "%s".', $reflection->getName(), $method));
  43.         }
  45.         $methodParams = $this->getParamsFromMethod($reflection->getMethod($method));
  46.         $classParams = $this->getParamsFromClass($reflection);
  48.         return array_merge($methodParams, $classParams);
  49.     }
  51.     /**
  52.      * {@inheritdoc}
  53.      */
  54.     public function getParamsFromMethod(\ReflectionMethod $method): array
  55.     {
  56.         $annotations = [];
  57.         if (\PHP_VERSION_ID >= 80000) {
  58.             $annotations = $this->getParamsFromAttributes($method);
  59.         }
  61.         if (null !== $this->annotationReader) {
  62.             $annotations = array_merge(
  63.                 $annotations,
  64.                 $this->annotationReader->getMethodAnnotations($method) ?? []
  65.             );
  66.         }
  68.         return $this->getParamsFromAnnotationArray($annotations);
  69.     }
  71.     /**
  72.      * {@inheritdoc}
  73.      */
  74.     public function getParamsFromClass(\ReflectionClass $class): array
  75.     {
  76.         $annotations = [];
  77.         if (\PHP_VERSION_ID >= 80000) {
  78.             $annotations = $this->getParamsFromAttributes($class);
  79.         }
  81.         if (null !== $this->annotationReader) {
  82.             $annotations = array_merge(
  83.                 $annotations,
  84.                 $this->annotationReader->getClassAnnotations($class) ?? []
  85.             );
  86.         }
  88.         return $this->getParamsFromAnnotationArray($annotations);
  89.     }
  91.     /**
  92.      * @return ParamInterface[]
  93.      */
  94.     private function getParamsFromAnnotationArray(array $annotations): array
  95.     {
  96.         $params = [];
  97.         foreach ($annotations as $annotation) {
  98.             if ($annotation instanceof ParamInterface) {
  99.                 $params[$annotation->getName()] = $annotation;
  100.             }
  101.         }
  103.         return $params;
  104.     }
  106.     /**
  107.      * @param \ReflectionClass|\ReflectionMethod $reflection
  108.      *
  109.      * @return ParamInterface[]
  110.      */
  111.     private function getParamsFromAttributes($reflection): array
  112.     {
  113.         $params = [];
  114.         foreach ($reflection->getAttributes(ParamInterface::class, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
  115.             $param = $attribute->newInstance();
  116.             $params[$param->getName()] = $param;
  117.         }
  119.         return $params;
  120.     }
  121. }