vendor/symfony/config/Resource/ClassExistenceResource.php line 78

Open in your IDE?
  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. /**
  15.  * ClassExistenceResource represents a class existence.
  16.  * Freshness is only evaluated against resource existence.
  17.  *
  18.  * The resource must be a fully-qualified class name.
  19.  *
  20.  * @author Fabien Potencier <fabien@symfony.com>
  21.  *
  22.  * @final since Symfony 4.3
  23.  */
  24. class ClassExistenceResource implements SelfCheckingResourceInterface
  25. {
  26.     private $resource;
  27.     private $exists;
  29.     private static $autoloadLevel = 0;
  30.     private static $autoloadedClass;
  31.     private static $existsCache = [];
  33.     /**
  34.      * @param string    $resource The fully-qualified class name
  35.      * @param bool|null $exists   Boolean when the existency check has already been done
  36.      */
  37.     public function __construct(string $resource, bool $exists = null)
  38.     {
  39.         $this->resource = $resource;
  40.         $this->exists = $exists;
  41.     }
  43.     /**
  44.      * {@inheritdoc}
  45.      */
  46.     public function __toString()
  47.     {
  48.         return $this->resource;
  49.     }
  51.     /**
  52.      * @return string The file path to the resource
  53.      */
  54.     public function getResource()
  55.     {
  56.         return $this->resource;
  57.     }
  59.     /**
  60.      * {@inheritdoc}
  61.      *
  62.      * @throws \ReflectionException when a parent class/interface/trait is not found
  63.      */
  64.     public function isFresh($timestamp)
  65.     {
  66.         $loaded = class_exists($this->resource, false) || interface_exists($this->resource, false) || trait_exists($this->resource, false);
  68.         if (null !== $exists = &self::$existsCache[(int) (0 >= $timestamp)][$this->resource]) {
  69.             $exists = $exists || $loaded;
  70.         } elseif (!$exists = $loaded) {
  71.             if (!self::$autoloadLevel++) {
  72.                 spl_autoload_register(__CLASS__.'::throwOnRequiredClass');
  73.             }
  74.             $autoloadedClass = self::$autoloadedClass;
  75.             self::$autoloadedClass = $this->resource;
  77.             try {
  78.                 $exists = class_exists($this->resource) || interface_exists($this->resource, false) || trait_exists($this->resource, false);
  79.             } catch (\Exception $e) {
  80.                 try {
  81.                     self::throwOnRequiredClass($this->resource, $e);
  82.                 } catch (\ReflectionException $e) {
  83.                     if (0 >= $timestamp) {
  84.                         unset(self::$existsCache[1][$this->resource]);
  85.                         throw $e;
  86.                     }
  87.                 }
  88.             } finally {
  89.                 self::$autoloadedClass = $autoloadedClass;
  90.                 if (!--self::$autoloadLevel) {
  91.                     spl_autoload_unregister(__CLASS__.'::throwOnRequiredClass');
  92.                 }
  93.             }
  94.         }
  96.         if (null === $this->exists) {
  97.             $this->exists = $exists;
  98.         }
  100.         return $this->exists xor !$exists;
  101.     }
  103.     /**
  104.      * @internal
  105.      */
  106.     public function __sleep(): array
  107.     {
  108.         if (null === $this->exists) {
  109.             $this->isFresh(0);
  110.         }
  112.         return ['resource', 'exists'];
  113.     }
  115.     /**
  116.      * Throws a reflection exception when the passed class does not exist but is required.
  117.      *
  118.      * A class is considered "not required" when it's loaded as part of a "class_exists" or similar check.
  119.      *
  120.      * This function can be used as an autoload function to throw a reflection
  121.      * exception if the class was not found by previous autoload functions.
  122.      *
  123.      * A previous exception can be passed. In this case, the class is considered as being
  124.      * required totally, so if it doesn't exist, a reflection exception is always thrown.
  125.      * If it exists, the previous exception is rethrown.
  126.      *
  127.      * @throws \ReflectionException
  128.      *
  129.      * @internal
  130.      */
  131.     public static function throwOnRequiredClass($class, \Exception $previous = null)
  132.     {
  133.         // If the passed class is the resource being checked, we shouldn't throw.
  134.         if (null === $previous && self::$autoloadedClass === $class) {
  135.             return;
  136.         }
  138.         if (class_exists($class, false) || interface_exists($class, false) || trait_exists($class, false)) {
  139.             if (null !== $previous) {
  140.                 throw $previous;
  141.             }
  143.             return;
  144.         }
  146.         if ($previous instanceof \ReflectionException) {
  147.             throw $previous;
  148.         }
  150.         $e = new \ReflectionException("Class $class not found", 0, $previous);
  152.         if (null !== $previous) {
  153.             throw $e;
  154.         }
  156.         $trace = $e->getTrace();
  157.         $autoloadFrame = [
  158.             'function' => 'spl_autoload_call',
  159.             'args' => [$class],
  160.         ];
  162.         if (false === $i = array_search($autoloadFrame, $trace, true)) {
  163.             throw $e;
  164.         }
  166.         if (isset($trace[++$i]['function']) && !isset($trace[$i]['class'])) {
  167.             switch ($trace[$i]['function']) {
  168.                 case 'get_class_methods':
  169.                 case 'get_class_vars':
  170.                 case 'get_parent_class':
  171.                 case 'is_a':
  172.                 case 'is_subclass_of':
  173.                 case 'class_exists':
  174.                 case 'class_implements':
  175.                 case 'class_parents':
  176.                 case 'trait_exists':
  177.                 case 'defined':
  178.                 case 'interface_exists':
  179.                 case 'method_exists':
  180.                 case 'property_exists':
  181.                 case 'is_callable':
  182.                     return;
  183.             }
  185.             $props = [
  186.                 'file' => $trace[$i]['file'],
  187.                 'line' => $trace[$i]['line'],
  188.                 'trace' => \array_slice($trace, 1 + $i),
  189.             ];
  191.             foreach ($props as $p => $v) {
  192.                 $r = new \ReflectionProperty('Exception', $p);
  193.                 $r->setAccessible(true);
  194.                 $r->setValue($e, $v);
  195.             }
  196.         }
  198.         throw $e;
  199.     }
  200. }