vendor/symfony/dependency-injection/Loader/PhpFileLoader.php line 151

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\DependencyInjection\Loader;
  14. use Symfony\Component\Config\Builder\ConfigBuilderGenerator;
  15. use Symfony\Component\Config\Builder\ConfigBuilderGeneratorInterface;
  16. use Symfony\Component\Config\Builder\ConfigBuilderInterface;
  17. use Symfony\Component\Config\FileLocatorInterface;
  18. use Symfony\Component\DependencyInjection\Attribute\When;
  19. use Symfony\Component\DependencyInjection\Container;
  20. use Symfony\Component\DependencyInjection\ContainerBuilder;
  21. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  22. use Symfony\Component\DependencyInjection\Extension\ConfigurationExtensionInterface;
  23. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  24. use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
  26. /**
  27.  * PhpFileLoader loads service definitions from a PHP file.
  28.  *
  29.  * The PHP file is required and the $container variable can be
  30.  * used within the file to change the container.
  31.  *
  32.  * @author Fabien Potencier <fabien@symfony.com>
  33.  */
  34. class PhpFileLoader extends FileLoader
  35. {
  36.     protected $autoRegisterAliasesForSinglyImplementedInterfaces = false;
  37.     private $generator;
  39.     public function __construct(ContainerBuilder $container, FileLocatorInterface $locator, ?string $env = null, ?ConfigBuilderGeneratorInterface $generator = null)
  40.     {
  41.         parent::__construct($container, $locator, $env);
  42.         $this->generator = $generator;
  43.     }
  45.     /**
  46.      * {@inheritdoc}
  47.      */
  48.     public function load($resource, ?string $type = null)
  49.     {
  50.         // the container and loader variables are exposed to the included file below
  51.         $container = $this->container;
  52.         $loader = $this;
  54.         $path = $this->locator->locate($resource);
  55.         $this->setCurrentDir(\dirname($path));
  56.         $this->container->fileExists($path);
  58.         // the closure forbids access to the private scope in the included file
  59.         $load = \Closure::bind(function ($path, $env) use ($container, $loader, $resource, $type) {
  60.             return include $path;
  61.         }, $this, ProtectedPhpFileLoader::class);
  63.         try {
  64.             $callback = $load($path, $this->env);
  66.             if (\is_object($callback) && \is_callable($callback)) {
  67.                 $this->executeCallback($callback, new ContainerConfigurator($this->container, $this, $this->instanceof, $path, $resource, $this->env), $path);
  68.             }
  69.         } finally {
  70.             $this->instanceof = [];
  71.             $this->registerAliasesForSinglyImplementedInterfaces();
  72.         }
  74.         return null;
  75.     }
  77.     /**
  78.      * {@inheritdoc}
  79.      */
  80.     public function supports($resource, ?string $type = null)
  81.     {
  82.         if (!\is_string($resource)) {
  83.             return false;
  84.         }
  86.         if (null === $type && 'php' === pathinfo($resource, \PATHINFO_EXTENSION)) {
  87.             return true;
  88.         }
  90.         return 'php' === $type;
  91.     }
  93.     /**
  94.      * Resolve the parameters to the $callback and execute it.
  95.      */
  96.     private function executeCallback(callable $callback, ContainerConfigurator $containerConfigurator, string $path)
  97.     {
  98.         if (!$callback instanceof \Closure) {
  99.             $callback = \Closure::fromCallable($callback);
  100.         }
  102.         $arguments = [];
  103.         $configBuilders = [];
  104.         $r = new \ReflectionFunction($callback);
  106.         if (\PHP_VERSION_ID >= 80000) {
  107.             $attribute = null;
  108.             foreach ($r->getAttributes(When::class) as $attribute) {
  109.                 if ($this->env === $attribute->newInstance()->env) {
  110.                     $attribute = null;
  111.                     break;
  112.                 }
  113.             }
  114.             if (null !== $attribute) {
  115.                 return;
  116.             }
  117.         }
  119.         foreach ($r->getParameters() as $parameter) {
  120.             $reflectionType = $parameter->getType();
  121.             if (!$reflectionType instanceof \ReflectionNamedType) {
  122.                 throw new \InvalidArgumentException(sprintf('Could not resolve argument "$%s" for "%s". You must typehint it (for example with "%s" or "%s").', $parameter->getName(), $path, ContainerConfigurator::class, ContainerBuilder::class));
  123.             }
  124.             $type = $reflectionType->getName();
  126.             switch ($type) {
  127.                 case ContainerConfigurator::class:
  128.                     $arguments[] = $containerConfigurator;
  129.                     break;
  130.                 case ContainerBuilder::class:
  131.                     $arguments[] = $this->container;
  132.                     break;
  133.                 case FileLoader::class:
  134.                 case self::class:
  135.                     $arguments[] = $this;
  136.                     break;
  137.                 default:
  138.                     try {
  139.                         $configBuilder = $this->configBuilder($type);
  140.                     } catch (InvalidArgumentException|\LogicException $e) {
  141.                         throw new \InvalidArgumentException(sprintf('Could not resolve argument "%s" for "%s".', $type.' $'.$parameter->getName(), $path), 0, $e);
  142.                     }
  143.                     $configBuilders[] = $configBuilder;
  144.                     $arguments[] = $configBuilder;
  145.             }
  146.         }
  148.         // Force load ContainerConfigurator to make env(), param() etc available.
  149.         class_exists(ContainerConfigurator::class);
  151.         $callback(...$arguments);
  153.         /** @var ConfigBuilderInterface $configBuilder */
  154.         foreach ($configBuilders as $configBuilder) {
  155.             $containerConfigurator->extension($configBuilder->getExtensionAlias(), $configBuilder->toArray());
  156.         }
  157.     }
  159.     /**
  160.      * @param string $namespace FQCN string for a class implementing ConfigBuilderInterface
  161.      */
  162.     private function configBuilder(string $namespace): ConfigBuilderInterface
  163.     {
  164.         if (!class_exists(ConfigBuilderGenerator::class)) {
  165.             throw new \LogicException('You cannot use the config builder as the Config component is not installed. Try running "composer require symfony/config".');
  166.         }
  168.         if (null === $this->generator) {
  169.             throw new \LogicException('You cannot use the ConfigBuilders without providing a class implementing ConfigBuilderGeneratorInterface.');
  170.         }
  172.         // If class exists and implements ConfigBuilderInterface
  173.         if (class_exists($namespace) && is_subclass_of($namespace, ConfigBuilderInterface::class)) {
  174.             return new $namespace();
  175.         }
  177.         // If it does not start with Symfony\Config\ we dont know how to handle this
  178.         if ('Symfony\\Config\\' !== substr($namespace, 0, 15)) {
  179.             throw new InvalidArgumentException(sprintf('Could not find or generate class "%s".', $namespace));
  180.         }
  182.         // Try to get the extension alias
  183.         $alias = Container::underscore(substr($namespace, 15, -6));
  185.         if (false !== strpos($alias, '\\')) {
  186.             throw new InvalidArgumentException('You can only use "root" ConfigBuilders from "Symfony\\Config\\" namespace. Nested classes like "Symfony\\Config\\Framework\\CacheConfig" cannot be used.');
  187.         }
  189.         if (!$this->container->hasExtension($alias)) {
  190.             $extensions = array_filter(array_map(function (ExtensionInterface $ext) { return $ext->getAlias(); }, $this->container->getExtensions()));
  191.             throw new InvalidArgumentException(sprintf('There is no extension able to load the configuration for "%s". Looked for namespace "%s", found "%s".', $namespace, $alias, $extensions ? implode('", "', $extensions) : 'none'));
  192.         }
  194.         $extension = $this->container->getExtension($alias);
  195.         if (!$extension instanceof ConfigurationExtensionInterface) {
  196.             throw new \LogicException(sprintf('You cannot use the config builder for "%s" because the extension does not implement "%s".', $namespace, ConfigurationExtensionInterface::class));
  197.         }
  199.         $configuration = $extension->getConfiguration([], $this->container);
  200.         $loader = $this->generator->build($configuration);
  202.         return $loader();
  203.     }
  204. }
  206. /**
  207.  * @internal
  208.  */
  209. final class ProtectedPhpFileLoader extends PhpFileLoader
  210. {
  211. }