vendor/symfony/dependency-injection/Loader/FileLoader.php line 121

  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\DependencyInjection\Loader;
  14. use Symfony\Component\Config\Exception\FileLocatorFileNotFoundException;
  15. use Symfony\Component\Config\Exception\LoaderLoadException;
  16. use Symfony\Component\Config\FileLocatorInterface;
  17. use Symfony\Component\Config\Loader\FileLoader as BaseFileLoader;
  18. use Symfony\Component\Config\Loader\Loader;
  19. use Symfony\Component\Config\Resource\GlobResource;
  20. use Symfony\Component\DependencyInjection\Attribute\When;
  21. use Symfony\Component\DependencyInjection\ChildDefinition;
  22. use Symfony\Component\DependencyInjection\Compiler\RegisterAutoconfigureAttributesPass;
  23. use Symfony\Component\DependencyInjection\ContainerBuilder;
  24. use Symfony\Component\DependencyInjection\Definition;
  25. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  27. /**
  28.  * FileLoader is the abstract class used by all built-in loaders that are file based.
  29.  *
  30.  * @author Fabien Potencier <fabien@symfony.com>
  31.  */
  32. abstract class FileLoader extends BaseFileLoader
  33. {
  34.     public const ANONYMOUS_ID_REGEXP = '/^\.\d+_[^~]*+~[._a-zA-Z\d]{7}$/';
  36.     protected $container;
  37.     protected $isLoadingInstanceof = false;
  38.     protected $instanceof = [];
  39.     protected $interfaces = [];
  40.     protected $singlyImplemented = [];
  41.     protected $autoRegisterAliasesForSinglyImplementedInterfaces = true;
  43.     public function __construct(ContainerBuilder $container, FileLocatorInterface $locator, string $env = null)
  44.     {
  45.         $this->container = $container;
  47.         parent::__construct($locator, $env);
  48.     }
  50.     /**
  51.      * @param bool|string $ignoreErrors Whether errors should be ignored; pass "not_found" to ignore only when the loaded resource is not found
  52.      */
  53.     public function import(mixed $resource, string $type = null, bool|string $ignoreErrors = false, string $sourceResource = null, $exclude = null): mixed
  54.     {
  55.         $args = \func_get_args();
  57.         if ($ignoreNotFound = 'not_found' === $ignoreErrors) {
  58.             $args[2] = false;
  59.         } elseif (!\is_bool($ignoreErrors)) {
  60.             throw new \TypeError(sprintf('Invalid argument $ignoreErrors provided to "%s::import()": boolean or "not_found" expected, "%s" given.', static::class, get_debug_type($ignoreErrors)));
  61.         }
  63.         try {
  64.             return parent::import(...$args);
  65.         } catch (LoaderLoadException $e) {
  66.             if (!$ignoreNotFound || !($prev = $e->getPrevious()) instanceof FileLocatorFileNotFoundException) {
  67.                 throw $e;
  68.             }
  70.             foreach ($prev->getTrace() as $frame) {
  71.                 if ('import' === ($frame['function'] ?? null) && is_a($frame['class'] ?? '', Loader::class, true)) {
  72.                     break;
  73.                 }
  74.             }
  76.             if (__FILE__ !== $frame['file']) {
  77.                 throw $e;
  78.             }
  79.         }
  81.         return null;
  82.     }
  84.     /**
  85.      * Registers a set of classes as services using PSR-4 for discovery.
  86.      *
  87.      * @param Definition           $prototype A definition to use as template
  88.      * @param string               $namespace The namespace prefix of classes in the scanned directory
  89.      * @param string               $resource  The directory to look for classes, glob-patterns allowed
  90.      * @param string|string[]|null $exclude   A globbed path of files to exclude or an array of globbed paths of files to exclude
  91.      * @param string|null          $source    The path to the file that defines the auto-discovery rule
  92.      */
  93.     public function registerClasses(Definition $prototype, string $namespace, string $resource, string|array $exclude = null/* , string $source = null */)
  94.     {
  95.         if (!str_ends_with($namespace, '\\')) {
  96.             throw new InvalidArgumentException(sprintf('Namespace prefix must end with a "\\": "%s".', $namespace));
  97.         }
  98.         if (!preg_match('/^(?:[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+\\\\)++$/', $namespace)) {
  99.             throw new InvalidArgumentException(sprintf('Namespace is not a valid PSR-4 prefix: "%s".', $namespace));
  100.         }
  101.         // This can happen with YAML files
  102.         if (\is_array($exclude) && \in_array(null, $exclude, true)) {
  103.             throw new InvalidArgumentException('The exclude list must not contain a "null" value.');
  104.         }
  105.         // This can happen with XML files
  106.         if (\is_array($exclude) && \in_array('', $exclude, true)) {
  107.             throw new InvalidArgumentException('The exclude list must not contain an empty value.');
  108.         }
  110.         $source = \func_num_args() > 4 ? func_get_arg(4) : null;
  111.         $autoconfigureAttributes = new RegisterAutoconfigureAttributesPass();
  112.         $autoconfigureAttributes = $autoconfigureAttributes->accept($prototype) ? $autoconfigureAttributes : null;
  113.         $classes = $this->findClasses($namespace, $resource, (array) $exclude, $autoconfigureAttributes, $source);
  114.         // prepare for deep cloning
  115.         $serializedPrototype = serialize($prototype);
  117.         foreach ($classes as $class => $errorMessage) {
  118.             if (null === $errorMessage && $autoconfigureAttributes && $this->env) {
  119.                 $r = $this->container->getReflectionClass($class);
  120.                 $attribute = null;
  121.                 foreach ($r->getAttributes(When::class, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
  122.                     if ($this->env === $attribute->newInstance()->env) {
  123.                         $attribute = null;
  124.                         break;
  125.                     }
  126.                 }
  127.                 if (null !== $attribute) {
  128.                     continue;
  129.                 }
  130.             }
  132.             if (interface_exists($class, false)) {
  133.                 $this->interfaces[] = $class;
  134.             } else {
  135.                 $this->setDefinition($class, $definition = unserialize($serializedPrototype));
  136.                 if (null !== $errorMessage) {
  137.                     $definition->addError($errorMessage);
  139.                     continue;
  140.                 }
  141.                 $definition->setClass($class);
  142.                 foreach (class_implements($class, false) as $interface) {
  143.                     $this->singlyImplemented[$interface] = ($this->singlyImplemented[$interface] ?? $class) !== $class ? false : $class;
  144.                 }
  145.             }
  146.         }
  148.         if ($this->autoRegisterAliasesForSinglyImplementedInterfaces) {
  149.             $this->registerAliasesForSinglyImplementedInterfaces();
  150.         }
  151.     }
  153.     public function registerAliasesForSinglyImplementedInterfaces()
  154.     {
  155.         foreach ($this->interfaces as $interface) {
  156.             if (!empty($this->singlyImplemented[$interface]) && !$this->container->has($interface)) {
  157.                 $this->container->setAlias($interface, $this->singlyImplemented[$interface]);
  158.             }
  159.         }
  161.         $this->interfaces = $this->singlyImplemented = [];
  162.     }
  164.     /**
  165.      * Registers a definition in the container with its instanceof-conditionals.
  166.      */
  167.     protected function setDefinition(string $id, Definition $definition)
  168.     {
  169.         $this->container->removeBindings($id);
  171.         if ($this->isLoadingInstanceof) {
  172.             if (!$definition instanceof ChildDefinition) {
  173.                 throw new InvalidArgumentException(sprintf('Invalid type definition "%s": ChildDefinition expected, "%s" given.', $id, get_debug_type($definition)));
  174.             }
  175.             $this->instanceof[$id] = $definition;
  176.         } else {
  177.             $this->container->setDefinition($id, $definition->setInstanceofConditionals($this->instanceof));
  178.         }
  179.     }
  181.     private function findClasses(string $namespace, string $pattern, array $excludePatterns, ?RegisterAutoconfigureAttributesPass $autoconfigureAttributes, ?string $source): array
  182.     {
  183.         $parameterBag = $this->container->getParameterBag();
  185.         $excludePaths = [];
  186.         $excludePrefix = null;
  187.         $excludePatterns = $parameterBag->unescapeValue($parameterBag->resolveValue($excludePatterns));
  188.         foreach ($excludePatterns as $excludePattern) {
  189.             foreach ($this->glob($excludePattern, true, $resource, true, true) as $path => $info) {
  190.                 $excludePrefix ??= $resource->getPrefix();
  192.                 // normalize Windows slashes and remove trailing slashes
  193.                 $excludePaths[rtrim(str_replace('\\', '/', $path), '/')] = true;
  194.             }
  195.         }
  197.         $pattern = $parameterBag->unescapeValue($parameterBag->resolveValue($pattern));
  198.         $classes = [];
  199.         $prefixLen = null;
  200.         foreach ($this->glob($pattern, true, $resource, false, false, $excludePaths) as $path => $info) {
  201.             if (null === $prefixLen) {
  202.                 $prefixLen = \strlen($resource->getPrefix());
  204.                 if ($excludePrefix && !str_starts_with($excludePrefix, $resource->getPrefix())) {
  205.                     throw new InvalidArgumentException(sprintf('Invalid "exclude" pattern when importing classes for "%s": make sure your "exclude" pattern (%s) is a subset of the "resource" pattern (%s).', $namespace, $excludePattern, $pattern));
  206.                 }
  207.             }
  209.             if (isset($excludePaths[str_replace('\\', '/', $path)])) {
  210.                 continue;
  211.             }
  213.             if (!str_ends_with($path, '.php') || !$info->isReadable()) {
  214.                 continue;
  215.             }
  216.             $class = $namespace.ltrim(str_replace('/', '\\', substr($path, $prefixLen, -4)), '\\');
  218.             if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+(?:\\\\[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+)*+$/', $class)) {
  219.                 continue;
  220.             }
  222.             try {
  223.                 $r = $this->container->getReflectionClass($class);
  224.             } catch (\ReflectionException $e) {
  225.                 $classes[$class] = $e->getMessage();
  226.                 continue;
  227.             }
  228.             // check to make sure the expected class exists
  229.             if (!$r) {
  230.                 throw new InvalidArgumentException(sprintf('Expected to find class "%s" in file "%s" while importing services from resource "%s", but it was not found! Check the namespace prefix used with the resource.', $class, $path, $pattern));
  231.             }
  233.             if ($r->isInstantiable() || $r->isInterface()) {
  234.                 $classes[$class] = null;
  235.             }
  237.             if ($autoconfigureAttributes && !$r->isInstantiable()) {
  238.                 $autoconfigureAttributes->processClass($this->container, $r);
  239.             }
  240.         }
  242.         // track only for new & removed files
  243.         if ($resource instanceof GlobResource) {
  244.             $this->container->addResource($resource);
  245.         } else {
  246.             foreach ($resource as $path) {
  247.                 $this->container->fileExists($path, false);
  248.             }
  249.         }
  251.         if (null !== $prefixLen) {
  252.             $attributes = null !== $source ? ['source' => sprintf('in "%s/%s"', basename(\dirname($source)), basename($source))] : [];
  254.             foreach ($excludePaths as $path => $_) {
  255.                 $class = $namespace.ltrim(str_replace('/', '\\', substr($path, $prefixLen, str_ends_with($path, '.php') ? -4 : null)), '\\');
  256.                 if (!$this->container->has($class)) {
  257.                     $this->container->register($class, $class)
  258.                         ->setAbstract(true)
  259.                         ->addTag('container.excluded', $attributes);
  260.                 }
  261.             }
  262.         }
  264.         return $classes;
  265.     }
  266. }