vendor/symfony/config/Resource/ReflectionClassResource.php line 51

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.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 Symfony\Component\Config\Resource;
  14. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  15. use Symfony\Component\Messenger\Handler\MessageSubscriberInterface;
  16. use Symfony\Contracts\Service\ServiceSubscriberInterface;
  18. /**
  19.  * @author Nicolas Grekas <p@tchwork.com>
  20.  *
  21.  * @final
  22.  */
  23. class ReflectionClassResource implements SelfCheckingResourceInterface
  24. {
  25.     private array $files = [];
  26.     private string $className;
  27.     private \ReflectionClass $classReflector;
  28.     private array $excludedVendors = [];
  29.     private string $hash;
  31.     public function __construct(\ReflectionClass $classReflector, array $excludedVendors = [])
  32.     {
  33.         $this->className = $classReflector->name;
  34.         $this->classReflector = $classReflector;
  35.         $this->excludedVendors = $excludedVendors;
  36.     }
  38.     public function isFresh(int $timestamp): bool
  39.     {
  40.         if (!isset($this->hash)) {
  41.             $this->hash = $this->computeHash();
  42.             $this->loadFiles($this->classReflector);
  43.         }
  45.         foreach ($this->files as $file => $v) {
  46.             if (false === $filemtime = @filemtime($file)) {
  47.                 return false;
  48.             }
  50.             if ($filemtime > $timestamp) {
  51.                 return $this->hash === $this->computeHash();
  52.             }
  53.         }
  55.         return true;
  56.     }
  58.     public function __toString(): string
  59.     {
  60.         return 'reflection.'.$this->className;
  61.     }
  63.     /**
  64.      * @internal
  65.      */
  66.     public function __sleep(): array
  67.     {
  68.         if (!isset($this->hash)) {
  69.             $this->hash = $this->computeHash();
  70.             $this->loadFiles($this->classReflector);
  71.         }
  73.         return ['files', 'className', 'hash'];
  74.     }
  76.     private function loadFiles(\ReflectionClass $class)
  77.     {
  78.         foreach ($class->getInterfaces() as $v) {
  79.             $this->loadFiles($v);
  80.         }
  81.         do {
  82.             $file = $class->getFileName();
  83.             if (false !== $file && is_file($file)) {
  84.                 foreach ($this->excludedVendors as $vendor) {
  85.                     if (str_starts_with($file, $vendor) && false !== strpbrk(substr($file, \strlen($vendor), 1), '/'.\DIRECTORY_SEPARATOR)) {
  86.                         $file = false;
  87.                         break;
  88.                     }
  89.                 }
  90.                 if ($file) {
  91.                     $this->files[$file] = null;
  92.                 }
  93.             }
  94.             foreach ($class->getTraits() as $v) {
  95.                 $this->loadFiles($v);
  96.             }
  97.         } while ($class = $class->getParentClass());
  98.     }
  100.     private function computeHash(): string
  101.     {
  102.         try {
  103.             $this->classReflector ??= new \ReflectionClass($this->className);
  104.         } catch (\ReflectionException) {
  105.             // the class does not exist anymore
  106.             return false;
  107.         }
  108.         $hash = hash_init('md5');
  110.         foreach ($this->generateSignature($this->classReflector) as $info) {
  111.             hash_update($hash, $info);
  112.         }
  114.         return hash_final($hash);
  115.     }
  117.     private function generateSignature(\ReflectionClass $class): iterable
  118.     {
  119.         $attributes = [];
  120.         foreach ($class->getAttributes() as $a) {
  121.             $attributes[] = [$a->getName(), (string) $a];
  122.         }
  123.         yield print_r($attributes, true);
  124.         $attributes = [];
  126.         yield $class->getDocComment();
  127.         yield (int) $class->isFinal();
  128.         yield (int) $class->isAbstract();
  130.         if ($class->isTrait()) {
  131.             yield print_r(class_uses($class->name), true);
  132.         } else {
  133.             yield print_r(class_parents($class->name), true);
  134.             yield print_r(class_implements($class->name), true);
  135.             yield print_r($class->getConstants(), true);
  136.         }
  138.         if (!$class->isInterface()) {
  139.             $defaults = $class->getDefaultProperties();
  141.             foreach ($class->getProperties(\ReflectionProperty::IS_PUBLIC | \ReflectionProperty::IS_PROTECTED) as $p) {
  142.                 foreach ($p->getAttributes() as $a) {
  143.                     $attributes[] = [$a->getName(), (string) $a];
  144.                 }
  145.                 yield print_r($attributes, true);
  146.                 $attributes = [];
  148.                 yield $p->getDocComment();
  149.                 yield $p->isDefault() ? '<default>' : '';
  150.                 yield $p->isPublic() ? 'public' : 'protected';
  151.                 yield $p->isStatic() ? 'static' : '';
  152.                 yield '$'.$p->name;
  153.                 yield print_r(isset($defaults[$p->name]) && !\is_object($defaults[$p->name]) ? $defaults[$p->name] : null, true);
  154.             }
  155.         }
  157.         $defined = \Closure::bind(static function ($c) { return \defined($c); }, null, $class->name);
  159.         foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC | \ReflectionMethod::IS_PROTECTED) as $m) {
  160.             foreach ($m->getAttributes() as $a) {
  161.                 $attributes[] = [$a->getName(), (string) $a];
  162.             }
  163.             yield print_r($attributes, true);
  164.             $attributes = [];
  166.             $defaults = [];
  167.             foreach ($m->getParameters() as $p) {
  168.                 foreach ($p->getAttributes() as $a) {
  169.                     $attributes[] = [$a->getName(), (string) $a];
  170.                 }
  171.                 yield print_r($attributes, true);
  172.                 $attributes = [];
  174.                 if (!$p->isDefaultValueAvailable()) {
  175.                     $defaults[$p->name] = null;
  177.                     continue;
  178.                 }
  180.                 $defaults[$p->name] = (string) $p;
  181.             }
  183.             yield preg_replace('/^  @@.*/m', '', $m);
  184.             yield print_r($defaults, true);
  185.         }
  187.         if ($class->isAbstract() || $class->isInterface() || $class->isTrait()) {
  188.             return;
  189.         }
  191.         if (interface_exists(EventSubscriberInterface::class, false) && $class->isSubclassOf(EventSubscriberInterface::class)) {
  192.             yield EventSubscriberInterface::class;
  193.             yield print_r($class->name::getSubscribedEvents(), true);
  194.         }
  196.         if (interface_exists(MessageSubscriberInterface::class, false) && $class->isSubclassOf(MessageSubscriberInterface::class)) {
  197.             yield MessageSubscriberInterface::class;
  198.             foreach ($class->name::getHandledMessages() as $key => $value) {
  199.                 yield $key.print_r($value, true);
  200.             }
  201.         }
  203.         if (interface_exists(ServiceSubscriberInterface::class, false) && $class->isSubclassOf(ServiceSubscriberInterface::class)) {
  204.             yield ServiceSubscriberInterface::class;
  205.             yield print_r($class->name::getSubscribedServices(), true);
  206.         }
  207.     }
  208. }