vendor/symfony/dependency-injection/Loader/YamlFileLoader.php line 733

  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\DependencyInjection\Alias;
  15. use Symfony\Component\DependencyInjection\Argument\AbstractArgument;
  16. use Symfony\Component\DependencyInjection\Argument\BoundArgument;
  17. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  18. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  19. use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
  20. use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
  21. use Symfony\Component\DependencyInjection\ChildDefinition;
  22. use Symfony\Component\DependencyInjection\ContainerBuilder;
  23. use Symfony\Component\DependencyInjection\ContainerInterface;
  24. use Symfony\Component\DependencyInjection\Definition;
  25. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  26. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  27. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  28. use Symfony\Component\DependencyInjection\Reference;
  29. use Symfony\Component\ExpressionLanguage\Expression;
  30. use Symfony\Component\Yaml\Exception\ParseException;
  31. use Symfony\Component\Yaml\Parser as YamlParser;
  32. use Symfony\Component\Yaml\Tag\TaggedValue;
  33. use Symfony\Component\Yaml\Yaml;
  35. /**
  36.  * YamlFileLoader loads YAML files service definitions.
  37.  *
  38.  * @author Fabien Potencier <fabien@symfony.com>
  39.  */
  40. class YamlFileLoader extends FileLoader
  41. {
  42.     private const SERVICE_KEYWORDS = [
  43.         'alias' => 'alias',
  44.         'parent' => 'parent',
  45.         'class' => 'class',
  46.         'shared' => 'shared',
  47.         'synthetic' => 'synthetic',
  48.         'lazy' => 'lazy',
  49.         'public' => 'public',
  50.         'abstract' => 'abstract',
  51.         'deprecated' => 'deprecated',
  52.         'factory' => 'factory',
  53.         'file' => 'file',
  54.         'arguments' => 'arguments',
  55.         'properties' => 'properties',
  56.         'configurator' => 'configurator',
  57.         'calls' => 'calls',
  58.         'tags' => 'tags',
  59.         'decorates' => 'decorates',
  60.         'decoration_inner_name' => 'decoration_inner_name',
  61.         'decoration_priority' => 'decoration_priority',
  62.         'decoration_on_invalid' => 'decoration_on_invalid',
  63.         'autowire' => 'autowire',
  64.         'autoconfigure' => 'autoconfigure',
  65.         'bind' => 'bind',
  66.     ];
  68.     private const PROTOTYPE_KEYWORDS = [
  69.         'resource' => 'resource',
  70.         'namespace' => 'namespace',
  71.         'exclude' => 'exclude',
  72.         'parent' => 'parent',
  73.         'shared' => 'shared',
  74.         'lazy' => 'lazy',
  75.         'public' => 'public',
  76.         'abstract' => 'abstract',
  77.         'deprecated' => 'deprecated',
  78.         'factory' => 'factory',
  79.         'arguments' => 'arguments',
  80.         'properties' => 'properties',
  81.         'configurator' => 'configurator',
  82.         'calls' => 'calls',
  83.         'tags' => 'tags',
  84.         'autowire' => 'autowire',
  85.         'autoconfigure' => 'autoconfigure',
  86.         'bind' => 'bind',
  87.     ];
  89.     private const INSTANCEOF_KEYWORDS = [
  90.         'shared' => 'shared',
  91.         'lazy' => 'lazy',
  92.         'public' => 'public',
  93.         'properties' => 'properties',
  94.         'configurator' => 'configurator',
  95.         'calls' => 'calls',
  96.         'tags' => 'tags',
  97.         'autowire' => 'autowire',
  98.         'bind' => 'bind',
  99.     ];
  101.     private const DEFAULTS_KEYWORDS = [
  102.         'public' => 'public',
  103.         'tags' => 'tags',
  104.         'autowire' => 'autowire',
  105.         'autoconfigure' => 'autoconfigure',
  106.         'bind' => 'bind',
  107.     ];
  109.     private YamlParser $yamlParser;
  111.     private int $anonymousServicesCount;
  112.     private string $anonymousServicesSuffix;
  114.     protected $autoRegisterAliasesForSinglyImplementedInterfaces = false;
  116.     public function load(mixed $resource, string $type = null): mixed
  117.     {
  118.         $path = $this->locator->locate($resource);
  120.         $content = $this->loadFile($path);
  122.         $this->container->fileExists($path);
  124.         // empty file
  125.         if (null === $content) {
  126.             return null;
  127.         }
  129.         $this->loadContent($content, $path);
  131.         // per-env configuration
  132.         if ($this->env && isset($content['when@'.$this->env])) {
  133.             if (!\is_array($content['when@'.$this->env])) {
  134.                 throw new InvalidArgumentException(sprintf('The "when@%s" key should contain an array in "%s". Check your YAML syntax.', $this->env, $path));
  135.             }
  137.             $env = $this->env;
  138.             $this->env = null;
  139.             try {
  140.                 $this->loadContent($content['when@'.$env], $path);
  141.             } finally {
  142.                 $this->env = $env;
  143.             }
  144.         }
  146.         return null;
  147.     }
  149.     private function loadContent(array $content, string $path)
  150.     {
  151.         // imports
  152.         $this->parseImports($content, $path);
  154.         // parameters
  155.         if (isset($content['parameters'])) {
  156.             if (!\is_array($content['parameters'])) {
  157.                 throw new InvalidArgumentException(sprintf('The "parameters" key should contain an array in "%s". Check your YAML syntax.', $path));
  158.             }
  160.             foreach ($content['parameters'] as $key => $value) {
  161.                 $this->container->setParameter($key, $this->resolveServices($value, $path, true));
  162.             }
  163.         }
  165.         // extensions
  166.         $this->loadFromExtensions($content);
  168.         // services
  169.         $this->anonymousServicesCount = 0;
  170.         $this->anonymousServicesSuffix = '~'.ContainerBuilder::hash($path);
  171.         $this->setCurrentDir(\dirname($path));
  172.         try {
  173.             $this->parseDefinitions($content, $path);
  174.         } finally {
  175.             $this->instanceof = [];
  176.             $this->registerAliasesForSinglyImplementedInterfaces();
  177.         }
  178.     }
  180.     public function supports(mixed $resource, string $type = null): bool
  181.     {
  182.         if (!\is_string($resource)) {
  183.             return false;
  184.         }
  186.         if (null === $type && \in_array(pathinfo($resource, \PATHINFO_EXTENSION), ['yaml', 'yml'], true)) {
  187.             return true;
  188.         }
  190.         return \in_array($type, ['yaml', 'yml'], true);
  191.     }
  193.     private function parseImports(array $content, string $file)
  194.     {
  195.         if (!isset($content['imports'])) {
  196.             return;
  197.         }
  199.         if (!\is_array($content['imports'])) {
  200.             throw new InvalidArgumentException(sprintf('The "imports" key should contain an array in "%s". Check your YAML syntax.', $file));
  201.         }
  203.         $defaultDirectory = \dirname($file);
  204.         foreach ($content['imports'] as $import) {
  205.             if (!\is_array($import)) {
  206.                 $import = ['resource' => $import];
  207.             }
  208.             if (!isset($import['resource'])) {
  209.                 throw new InvalidArgumentException(sprintf('An import should provide a resource in "%s". Check your YAML syntax.', $file));
  210.             }
  212.             $this->setCurrentDir($defaultDirectory);
  213.             $this->import($import['resource'], $import['type'] ?? null, $import['ignore_errors'] ?? false, $file);
  214.         }
  215.     }
  217.     private function parseDefinitions(array $content, string $file, bool $trackBindings = true)
  218.     {
  219.         if (!isset($content['services'])) {
  220.             return;
  221.         }
  223.         if (!\is_array($content['services'])) {
  224.             throw new InvalidArgumentException(sprintf('The "services" key should contain an array in "%s". Check your YAML syntax.', $file));
  225.         }
  227.         if (\array_key_exists('_instanceof', $content['services'])) {
  228.             $instanceof = $content['services']['_instanceof'];
  229.             unset($content['services']['_instanceof']);
  231.             if (!\is_array($instanceof)) {
  232.                 throw new InvalidArgumentException(sprintf('Service "_instanceof" key must be an array, "%s" given in "%s".', get_debug_type($instanceof), $file));
  233.             }
  234.             $this->instanceof = [];
  235.             $this->isLoadingInstanceof = true;
  236.             foreach ($instanceof as $id => $service) {
  237.                 if (!$service || !\is_array($service)) {
  238.                     throw new InvalidArgumentException(sprintf('Type definition "%s" must be a non-empty array within "_instanceof" in "%s". Check your YAML syntax.', $id, $file));
  239.                 }
  240.                 if (\is_string($service) && str_starts_with($service, '@')) {
  241.                     throw new InvalidArgumentException(sprintf('Type definition "%s" cannot be an alias within "_instanceof" in "%s". Check your YAML syntax.', $id, $file));
  242.                 }
  243.                 $this->parseDefinition($id, $service, $file, [], false, $trackBindings);
  244.             }
  245.         }
  247.         $this->isLoadingInstanceof = false;
  248.         $defaults = $this->parseDefaults($content, $file);
  249.         foreach ($content['services'] as $id => $service) {
  250.             $this->parseDefinition($id, $service, $file, $defaults, false, $trackBindings);
  251.         }
  252.     }
  254.     /**
  255.      * @throws InvalidArgumentException
  256.      */
  257.     private function parseDefaults(array &$content, string $file): array
  258.     {
  259.         if (!\array_key_exists('_defaults', $content['services'])) {
  260.             return [];
  261.         }
  262.         $defaults = $content['services']['_defaults'];
  263.         unset($content['services']['_defaults']);
  265.         if (!\is_array($defaults)) {
  266.             throw new InvalidArgumentException(sprintf('Service "_defaults" key must be an array, "%s" given in "%s".', get_debug_type($defaults), $file));
  267.         }
  269.         foreach ($defaults as $key => $default) {
  270.             if (!isset(self::DEFAULTS_KEYWORDS[$key])) {
  271.                 throw new InvalidArgumentException(sprintf('The configuration key "%s" cannot be used to define a default value in "%s". Allowed keys are "%s".', $key, $file, implode('", "', self::DEFAULTS_KEYWORDS)));
  272.             }
  273.         }
  275.         if (isset($defaults['tags'])) {
  276.             if (!\is_array($tags = $defaults['tags'])) {
  277.                 throw new InvalidArgumentException(sprintf('Parameter "tags" in "_defaults" must be an array in "%s". Check your YAML syntax.', $file));
  278.             }
  280.             foreach ($tags as $tag) {
  281.                 if (!\is_array($tag)) {
  282.                     $tag = ['name' => $tag];
  283.                 }
  285.                 if (1 === \count($tag) && \is_array(current($tag))) {
  286.                     $name = key($tag);
  287.                     $tag = current($tag);
  288.                 } else {
  289.                     if (!isset($tag['name'])) {
  290.                         throw new InvalidArgumentException(sprintf('A "tags" entry in "_defaults" is missing a "name" key in "%s".', $file));
  291.                     }
  292.                     $name = $tag['name'];
  293.                     unset($tag['name']);
  294.                 }
  296.                 if (!\is_string($name) || '' === $name) {
  297.                     throw new InvalidArgumentException(sprintf('The tag name in "_defaults" must be a non-empty string in "%s".', $file));
  298.                 }
  300.                 $this->validateAttributes(sprintf('Tag "%s", attribute "%s" in "_defaults" must be of a scalar-type in "%s". Check your YAML syntax.', $name, '%s', $file), $tag);
  301.             }
  302.         }
  304.         if (isset($defaults['bind'])) {
  305.             if (!\is_array($defaults['bind'])) {
  306.                 throw new InvalidArgumentException(sprintf('Parameter "bind" in "_defaults" must be an array in "%s". Check your YAML syntax.', $file));
  307.             }
  309.             foreach ($this->resolveServices($defaults['bind'], $file) as $argument => $value) {
  310.                 $defaults['bind'][$argument] = new BoundArgument($value, true, BoundArgument::DEFAULTS_BINDING, $file);
  311.             }
  312.         }
  314.         return $defaults;
  315.     }
  317.     private function isUsingShortSyntax(array $service): bool
  318.     {
  319.         foreach ($service as $key => $value) {
  320.             if (\is_string($key) && ('' === $key || ('$' !== $key[0] && !str_contains($key, '\\')))) {
  321.                 return false;
  322.             }
  323.         }
  325.         return true;
  326.     }
  328.     /**
  329.      * @throws InvalidArgumentException When tags are invalid
  330.      */
  331.     private function parseDefinition(string $id, array|string|null $service, string $file, array $defaults, bool $return = false, bool $trackBindings = true)
  332.     {
  333.         if (preg_match('/^_[a-zA-Z0-9_]*$/', $id)) {
  334.             throw new InvalidArgumentException(sprintf('Service names that start with an underscore are reserved. Rename the "%s" service or define it in XML instead.', $id));
  335.         }
  337.         if (\is_string($service) && str_starts_with($service, '@')) {
  338.             $alias = new Alias(substr($service, 1));
  340.             if (isset($defaults['public'])) {
  341.                 $alias->setPublic($defaults['public']);
  342.             }
  344.             return $return ? $alias : $this->container->setAlias($id, $alias);
  345.         }
  347.         if (\is_array($service) && $this->isUsingShortSyntax($service)) {
  348.             $service = ['arguments' => $service];
  349.         }
  351.         if (!\is_array($service ??= [])) {
  352.             throw new InvalidArgumentException(sprintf('A service definition must be an array or a string starting with "@" but "%s" found for service "%s" in "%s". Check your YAML syntax.', get_debug_type($service), $id, $file));
  353.         }
  355.         if (isset($service['stack'])) {
  356.             if (!\is_array($service['stack'])) {
  357.                 throw new InvalidArgumentException(sprintf('A stack must be an array of definitions, "%s" given for service "%s" in "%s". Check your YAML syntax.', get_debug_type($service), $id, $file));
  358.             }
  360.             $stack = [];
  362.             foreach ($service['stack'] as $k => $frame) {
  363.                 if (\is_array($frame) && 1 === \count($frame) && !isset(self::SERVICE_KEYWORDS[key($frame)])) {
  364.                     $frame = [
  365.                         'class' => key($frame),
  366.                         'arguments' => current($frame),
  367.                     ];
  368.                 }
  370.                 if (\is_array($frame) && isset($frame['stack'])) {
  371.                     throw new InvalidArgumentException(sprintf('Service stack "%s" cannot contain another stack in "%s".', $id, $file));
  372.                 }
  374.                 $definition = $this->parseDefinition($id.'" at index "'.$k, $frame, $file, $defaults, true);
  376.                 if ($definition instanceof Definition) {
  377.                     $definition->setInstanceofConditionals($this->instanceof);
  378.                 }
  380.                 $stack[$k] = $definition;
  381.             }
  383.             if ($diff = array_diff(array_keys($service), ['stack', 'public', 'deprecated'])) {
  384.                 throw new InvalidArgumentException(sprintf('Invalid attribute "%s"; supported ones are "public" and "deprecated" for service "%s" in "%s". Check your YAML syntax.', implode('", "', $diff), $id, $file));
  385.             }
  387.             $service = [
  388.                 'parent' => '',
  389.                 'arguments' => $stack,
  390.                 'tags' => ['container.stack'],
  391.                 'public' => $service['public'] ?? null,
  392.                 'deprecated' => $service['deprecated'] ?? null,
  393.             ];
  394.         }
  396.         $definition = isset($service[0]) && $service[0] instanceof Definition ? array_shift($service) : null;
  397.         $return = null === $definition ? $return : true;
  399.         $this->checkDefinition($id, $service, $file);
  401.         if (isset($service['alias'])) {
  402.             $alias = new Alias($service['alias']);
  404.             if (isset($service['public'])) {
  405.                 $alias->setPublic($service['public']);
  406.             } elseif (isset($defaults['public'])) {
  407.                 $alias->setPublic($defaults['public']);
  408.             }
  410.             foreach ($service as $key => $value) {
  411.                 if (!\in_array($key, ['alias', 'public', 'deprecated'])) {
  412.                     throw new InvalidArgumentException(sprintf('The configuration key "%s" is unsupported for the service "%s" which is defined as an alias in "%s". Allowed configuration keys for service aliases are "alias", "public" and "deprecated".', $key, $id, $file));
  413.                 }
  415.                 if ('deprecated' === $key) {
  416.                     $deprecation = \is_array($value) ? $value : ['message' => $value];
  418.                     if (!isset($deprecation['package'])) {
  419.                         throw new InvalidArgumentException(sprintf('Missing attribute "package" of the "deprecated" option in "%s".', $file));
  420.                     }
  422.                     if (!isset($deprecation['version'])) {
  423.                         throw new InvalidArgumentException(sprintf('Missing attribute "version" of the "deprecated" option in "%s".', $file));
  424.                     }
  426.                     $alias->setDeprecated($deprecation['package'] ?? '', $deprecation['version'] ?? '', $deprecation['message'] ?? '');
  427.                 }
  428.             }
  430.             return $return ? $alias : $this->container->setAlias($id, $alias);
  431.         }
  433.         if (null !== $definition) {
  434.             // no-op
  435.         } elseif ($this->isLoadingInstanceof) {
  436.             $definition = new ChildDefinition('');
  437.         } elseif (isset($service['parent'])) {
  438.             if ('' !== $service['parent'] && '@' === $service['parent'][0]) {
  439.                 throw new InvalidArgumentException(sprintf('The value of the "parent" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s").', $id, $service['parent'], substr($service['parent'], 1)));
  440.             }
  442.             $definition = new ChildDefinition($service['parent']);
  443.         } else {
  444.             $definition = new Definition();
  445.         }
  447.         if (isset($defaults['public'])) {
  448.             $definition->setPublic($defaults['public']);
  449.         }
  450.         if (isset($defaults['autowire'])) {
  451.             $definition->setAutowired($defaults['autowire']);
  452.         }
  453.         if (isset($defaults['autoconfigure'])) {
  454.             $definition->setAutoconfigured($defaults['autoconfigure']);
  455.         }
  457.         $definition->setChanges([]);
  459.         if (isset($service['class'])) {
  460.             $definition->setClass($service['class']);
  461.         }
  463.         if (isset($service['shared'])) {
  464.             $definition->setShared($service['shared']);
  465.         }
  467.         if (isset($service['synthetic'])) {
  468.             $definition->setSynthetic($service['synthetic']);
  469.         }
  471.         if (isset($service['lazy'])) {
  472.             $definition->setLazy((bool) $service['lazy']);
  473.             if (\is_string($service['lazy'])) {
  474.                 $definition->addTag('proxy', ['interface' => $service['lazy']]);
  475.             }
  476.         }
  478.         if (isset($service['public'])) {
  479.             $definition->setPublic($service['public']);
  480.         }
  482.         if (isset($service['abstract'])) {
  483.             $definition->setAbstract($service['abstract']);
  484.         }
  486.         if (isset($service['deprecated'])) {
  487.             $deprecation = \is_array($service['deprecated']) ? $service['deprecated'] : ['message' => $service['deprecated']];
  489.             if (!isset($deprecation['package'])) {
  490.                 throw new InvalidArgumentException(sprintf('Missing attribute "package" of the "deprecated" option in "%s".', $file));
  491.             }
  493.             if (!isset($deprecation['version'])) {
  494.                 throw new InvalidArgumentException(sprintf('Missing attribute "version" of the "deprecated" option in "%s".', $file));
  495.             }
  497.             $definition->setDeprecated($deprecation['package'] ?? '', $deprecation['version'] ?? '', $deprecation['message'] ?? '');
  498.         }
  500.         if (isset($service['factory'])) {
  501.             $definition->setFactory($this->parseCallable($service['factory'], 'factory', $id, $file));
  502.         }
  504.         if (isset($service['file'])) {
  505.             $definition->setFile($service['file']);
  506.         }
  508.         if (isset($service['arguments'])) {
  509.             $definition->setArguments($this->resolveServices($service['arguments'], $file));
  510.         }
  512.         if (isset($service['properties'])) {
  513.             $definition->setProperties($this->resolveServices($service['properties'], $file));
  514.         }
  516.         if (isset($service['configurator'])) {
  517.             $definition->setConfigurator($this->parseCallable($service['configurator'], 'configurator', $id, $file));
  518.         }
  520.         if (isset($service['calls'])) {
  521.             if (!\is_array($service['calls'])) {
  522.                 throw new InvalidArgumentException(sprintf('Parameter "calls" must be an array for service "%s" in "%s". Check your YAML syntax.', $id, $file));
  523.             }
  525.             foreach ($service['calls'] as $k => $call) {
  526.                 if (!\is_array($call) && (!\is_string($k) || !$call instanceof TaggedValue)) {
  527.                     throw new InvalidArgumentException(sprintf('Invalid method call for service "%s": expected map or array, "%s" given in "%s".', $id, $call instanceof TaggedValue ? '!'.$call->getTag() : get_debug_type($call), $file));
  528.                 }
  530.                 if (\is_string($k)) {
  531.                     throw new InvalidArgumentException(sprintf('Invalid method call for service "%s", did you forgot a leading dash before "%s: ..." in "%s"?', $id, $k, $file));
  532.                 }
  534.                 if (isset($call['method']) && \is_string($call['method'])) {
  535.                     $method = $call['method'];
  536.                     $args = $call['arguments'] ?? [];
  537.                     $returnsClone = $call['returns_clone'] ?? false;
  538.                 } else {
  539.                     if (1 === \count($call) && \is_string(key($call))) {
  540.                         $method = key($call);
  541.                         $args = $call[$method];
  543.                         if ($args instanceof TaggedValue) {
  544.                             if ('returns_clone' !== $args->getTag()) {
  545.                                 throw new InvalidArgumentException(sprintf('Unsupported tag "!%s", did you mean "!returns_clone" for service "%s" in "%s"?', $args->getTag(), $id, $file));
  546.                             }
  548.                             $returnsClone = true;
  549.                             $args = $args->getValue();
  550.                         } else {
  551.                             $returnsClone = false;
  552.                         }
  553.                     } elseif (empty($call[0])) {
  554.                         throw new InvalidArgumentException(sprintf('Invalid call for service "%s": the method must be defined as the first index of an array or as the only key of a map in "%s".', $id, $file));
  555.                     } else {
  556.                         $method = $call[0];
  557.                         $args = $call[1] ?? [];
  558.                         $returnsClone = $call[2] ?? false;
  559.                     }
  560.                 }
  562.                 if (!\is_array($args)) {
  563.                     throw new InvalidArgumentException(sprintf('The second parameter for function call "%s" must be an array of its arguments for service "%s" in "%s". Check your YAML syntax.', $method, $id, $file));
  564.                 }
  566.                 $args = $this->resolveServices($args, $file);
  567.                 $definition->addMethodCall($method, $args, $returnsClone);
  568.             }
  569.         }
  571.         $tags = $service['tags'] ?? [];
  572.         if (!\is_array($tags)) {
  573.             throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in "%s". Check your YAML syntax.', $id, $file));
  574.         }
  576.         if (isset($defaults['tags'])) {
  577.             $tags = array_merge($tags, $defaults['tags']);
  578.         }
  580.         foreach ($tags as $tag) {
  581.             if (!\is_array($tag)) {
  582.                 $tag = ['name' => $tag];
  583.             }
  585.             if (1 === \count($tag) && \is_array(current($tag))) {
  586.                 $name = key($tag);
  587.                 $tag = current($tag);
  588.             } else {
  589.                 if (!isset($tag['name'])) {
  590.                     throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in "%s".', $id, $file));
  591.                 }
  592.                 $name = $tag['name'];
  593.                 unset($tag['name']);
  594.             }
  596.             if (!\is_string($name) || '' === $name) {
  597.                 throw new InvalidArgumentException(sprintf('The tag name for service "%s" in "%s" must be a non-empty string.', $id, $file));
  598.             }
  600.             $this->validateAttributes(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s", attribute "%s" in "%s". Check your YAML syntax.', $id, $name, '%s', $file), $tag);
  602.             $definition->addTag($name, $tag);
  603.         }
  605.         if (null !== $decorates = $service['decorates'] ?? null) {
  606.             if ('' !== $decorates && '@' === $decorates[0]) {
  607.                 throw new InvalidArgumentException(sprintf('The value of the "decorates" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s").', $id, $service['decorates'], substr($decorates, 1)));
  608.             }
  610.             $decorationOnInvalid = \array_key_exists('decoration_on_invalid', $service) ? $service['decoration_on_invalid'] : 'exception';
  611.             if ('exception' === $decorationOnInvalid) {
  612.                 $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
  613.             } elseif ('ignore' === $decorationOnInvalid) {
  614.                 $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
  615.             } elseif (null === $decorationOnInvalid) {
  616.                 $invalidBehavior = ContainerInterface::NULL_ON_INVALID_REFERENCE;
  617.             } elseif ('null' === $decorationOnInvalid) {
  618.                 throw new InvalidArgumentException(sprintf('Invalid value "%s" for attribute "decoration_on_invalid" on service "%s". Did you mean null (without quotes) in "%s"?', $decorationOnInvalid, $id, $file));
  619.             } else {
  620.                 throw new InvalidArgumentException(sprintf('Invalid value "%s" for attribute "decoration_on_invalid" on service "%s". Did you mean "exception", "ignore" or null in "%s"?', $decorationOnInvalid, $id, $file));
  621.             }
  623.             $renameId = $service['decoration_inner_name'] ?? null;
  624.             $priority = $service['decoration_priority'] ?? 0;
  626.             $definition->setDecoratedService($decorates, $renameId, $priority, $invalidBehavior);
  627.         }
  629.         if (isset($service['autowire'])) {
  630.             $definition->setAutowired($service['autowire']);
  631.         }
  633.         if (isset($defaults['bind']) || isset($service['bind'])) {
  634.             // deep clone, to avoid multiple process of the same instance in the passes
  635.             $bindings = $definition->getBindings();
  636.             $bindings += isset($defaults['bind']) ? unserialize(serialize($defaults['bind'])) : [];
  638.             if (isset($service['bind'])) {
  639.                 if (!\is_array($service['bind'])) {
  640.                     throw new InvalidArgumentException(sprintf('Parameter "bind" must be an array for service "%s" in "%s". Check your YAML syntax.', $id, $file));
  641.                 }
  643.                 $bindings = array_merge($bindings, $this->resolveServices($service['bind'], $file));
  644.                 $bindingType = $this->isLoadingInstanceof ? BoundArgument::INSTANCEOF_BINDING : BoundArgument::SERVICE_BINDING;
  645.                 foreach ($bindings as $argument => $value) {
  646.                     if (!$value instanceof BoundArgument) {
  647.                         $bindings[$argument] = new BoundArgument($value, $trackBindings, $bindingType, $file);
  648.                     }
  649.                 }
  650.             }
  652.             $definition->setBindings($bindings);
  653.         }
  655.         if (isset($service['autoconfigure'])) {
  656.             $definition->setAutoconfigured($service['autoconfigure']);
  657.         }
  659.         if (\array_key_exists('namespace', $service) && !\array_key_exists('resource', $service)) {
  660.             throw new InvalidArgumentException(sprintf('A "resource" attribute must be set when the "namespace" attribute is set for service "%s" in "%s". Check your YAML syntax.', $id, $file));
  661.         }
  663.         if ($return) {
  664.             if (\array_key_exists('resource', $service)) {
  665.                 throw new InvalidArgumentException(sprintf('Invalid "resource" attribute found for service "%s" in "%s". Check your YAML syntax.', $id, $file));
  666.             }
  668.             return $definition;
  669.         }
  671.         if (\array_key_exists('resource', $service)) {
  672.             if (!\is_string($service['resource'])) {
  673.                 throw new InvalidArgumentException(sprintf('A "resource" attribute must be of type string for service "%s" in "%s". Check your YAML syntax.', $id, $file));
  674.             }
  675.             $exclude = $service['exclude'] ?? null;
  676.             $namespace = $service['namespace'] ?? $id;
  677.             $this->registerClasses($definition, $namespace, $service['resource'], $exclude, $file);
  678.         } else {
  679.             $this->setDefinition($id, $definition);
  680.         }
  681.     }
  683.     /**
  684.      * @throws InvalidArgumentException When errors occur
  685.      */
  686.     private function parseCallable(mixed $callable, string $parameter, string $id, string $file): string|array|Reference
  687.     {
  688.         if (\is_string($callable)) {
  689.             if (str_starts_with($callable, '@=')) {
  690.                 if ('factory' !== $parameter) {
  691.                     throw new InvalidArgumentException(sprintf('Using expressions in "%s" for the "%s" service is not supported in "%s".', $parameter, $id, $file));
  692.                 }
  693.                 if (!class_exists(Expression::class)) {
  694.                     throw new \LogicException('The "@=" expression syntax cannot be used without the ExpressionLanguage component. Try running "composer require symfony/expression-language".');
  695.                 }
  697.                 return $callable;
  698.             }
  700.             if ('' !== $callable && '@' === $callable[0]) {
  701.                 if (!str_contains($callable, ':')) {
  702.                     return [$this->resolveServices($callable, $file), '__invoke'];
  703.                 }
  705.                 throw new InvalidArgumentException(sprintf('The value of the "%s" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s" in "%s").', $parameter, $id, $callable, substr($callable, 1), $file));
  706.             }
  708.             return $callable;
  709.         }
  711.         if (\is_array($callable)) {
  712.             if (isset($callable[0]) && isset($callable[1])) {
  713.                 return [$this->resolveServices($callable[0], $file), $callable[1]];
  714.             }
  716.             if ('factory' === $parameter && isset($callable[1]) && null === $callable[0]) {
  717.                 return $callable;
  718.             }
  720.             throw new InvalidArgumentException(sprintf('Parameter "%s" must contain an array with two elements for service "%s" in "%s". Check your YAML syntax.', $parameter, $id, $file));
  721.         }
  723.         throw new InvalidArgumentException(sprintf('Parameter "%s" must be a string or an array for service "%s" in "%s". Check your YAML syntax.', $parameter, $id, $file));
  724.     }
  726.     /**
  727.      * Loads a YAML file.
  728.      *
  729.      * @throws InvalidArgumentException when the given file is not a local file or when it does not exist
  730.      */
  731.     protected function loadFile(string $file): ?array
  732.     {
  733.         if (!class_exists(\Symfony\Component\Yaml\Parser::class)) {
  734.             throw new RuntimeException('Unable to load YAML config files as the Symfony Yaml Component is not installed.');
  735.         }
  737.         if (!stream_is_local($file)) {
  738.             throw new InvalidArgumentException(sprintf('This is not a local file "%s".', $file));
  739.         }
  741.         if (!is_file($file)) {
  742.             throw new InvalidArgumentException(sprintf('The file "%s" does not exist.', $file));
  743.         }
  745.         $this->yamlParser ??= new YamlParser();
  747.         try {
  748.             $configuration = $this->yamlParser->parseFile($file, Yaml::PARSE_CONSTANT | Yaml::PARSE_CUSTOM_TAGS);
  749.         } catch (ParseException $e) {
  750.             throw new InvalidArgumentException(sprintf('The file "%s" does not contain valid YAML: ', $file).$e->getMessage(), 0, $e);
  751.         }
  753.         return $this->validate($configuration, $file);
  754.     }
  756.     /**
  757.      * Validates a YAML file.
  758.      *
  759.      * @throws InvalidArgumentException When service file is not valid
  760.      */
  761.     private function validate(mixed $content, string $file): ?array
  762.     {
  763.         if (null === $content) {
  764.             return $content;
  765.         }
  767.         if (!\is_array($content)) {
  768.             throw new InvalidArgumentException(sprintf('The service file "%s" is not valid. It should contain an array. Check your YAML syntax.', $file));
  769.         }
  771.         foreach ($content as $namespace => $data) {
  772.             if (\in_array($namespace, ['imports', 'parameters', 'services']) || str_starts_with($namespace, 'when@')) {
  773.                 continue;
  774.             }
  776.             if (!$this->container->hasExtension($namespace)) {
  777.                 $extensionNamespaces = array_filter(array_map(function (ExtensionInterface $ext) { return $ext->getAlias(); }, $this->container->getExtensions()));
  778.                 throw new InvalidArgumentException(sprintf('There is no extension able to load the configuration for "%s" (in "%s"). Looked for namespace "%s", found "%s".', $namespace, $file, $namespace, $extensionNamespaces ? sprintf('"%s"', implode('", "', $extensionNamespaces)) : 'none'));
  779.             }
  780.         }
  782.         return $content;
  783.     }
  785.     private function resolveServices(mixed $value, string $file, bool $isParameter = false): mixed
  786.     {
  787.         if ($value instanceof TaggedValue) {
  788.             $argument = $value->getValue();
  790.             if ('closure' === $value->getTag()) {
  791.                 $argument = $this->resolveServices($argument, $file, $isParameter);
  793.                 return (new Definition('Closure'))
  794.                     ->setFactory(['Closure', 'fromCallable'])
  795.                     ->addArgument($argument);
  796.             }
  797.             if ('iterator' === $value->getTag()) {
  798.                 if (!\is_array($argument)) {
  799.                     throw new InvalidArgumentException(sprintf('"!iterator" tag only accepts sequences in "%s".', $file));
  800.                 }
  801.                 $argument = $this->resolveServices($argument, $file, $isParameter);
  803.                 return new IteratorArgument($argument);
  804.             }
  805.             if ('service_closure' === $value->getTag()) {
  806.                 $argument = $this->resolveServices($argument, $file, $isParameter);
  808.                 return new ServiceClosureArgument($argument);
  809.             }
  810.             if ('service_locator' === $value->getTag()) {
  811.                 if (!\is_array($argument)) {
  812.                     throw new InvalidArgumentException(sprintf('"!service_locator" tag only accepts maps in "%s".', $file));
  813.                 }
  815.                 $argument = $this->resolveServices($argument, $file, $isParameter);
  817.                 return new ServiceLocatorArgument($argument);
  818.             }
  819.             if (\in_array($value->getTag(), ['tagged', 'tagged_iterator', 'tagged_locator'], true)) {
  820.                 $forLocator = 'tagged_locator' === $value->getTag();
  822.                 if (\is_array($argument) && isset($argument['tag']) && $argument['tag']) {
  823.                     if ($diff = array_diff(array_keys($argument), $supportedKeys = ['tag', 'index_by', 'default_index_method', 'default_priority_method', 'exclude'])) {
  824.                         throw new InvalidArgumentException(sprintf('"!%s" tag contains unsupported key "%s"; supported ones are "%s".', $value->getTag(), implode('", "', $diff), implode('", "', $supportedKeys)));
  825.                     }
  827.                     $argument = new TaggedIteratorArgument($argument['tag'], $argument['index_by'] ?? null, $argument['default_index_method'] ?? null, $forLocator, $argument['default_priority_method'] ?? null, (array) ($argument['exclude'] ?? null));
  828.                 } elseif (\is_string($argument) && $argument) {
  829.                     $argument = new TaggedIteratorArgument($argument, null, null, $forLocator);
  830.                 } else {
  831.                     throw new InvalidArgumentException(sprintf('"!%s" tags only accept a non empty string or an array with a key "tag" in "%s".', $value->getTag(), $file));
  832.                 }
  834.                 if ($forLocator) {
  835.                     $argument = new ServiceLocatorArgument($argument);
  836.                 }
  838.                 return $argument;
  839.             }
  840.             if ('service' === $value->getTag()) {
  841.                 if ($isParameter) {
  842.                     throw new InvalidArgumentException(sprintf('Using an anonymous service in a parameter is not allowed in "%s".', $file));
  843.                 }
  845.                 $isLoadingInstanceof = $this->isLoadingInstanceof;
  846.                 $this->isLoadingInstanceof = false;
  847.                 $instanceof = $this->instanceof;
  848.                 $this->instanceof = [];
  850.                 $id = sprintf('.%d_%s', ++$this->anonymousServicesCount, preg_replace('/^.*\\\\/', '', $argument['class'] ?? '').$this->anonymousServicesSuffix);
  851.                 $this->parseDefinition($id, $argument, $file, []);
  853.                 if (!$this->container->hasDefinition($id)) {
  854.                     throw new InvalidArgumentException(sprintf('Creating an alias using the tag "!service" is not allowed in "%s".', $file));
  855.                 }
  857.                 $this->container->getDefinition($id);
  859.                 $this->isLoadingInstanceof = $isLoadingInstanceof;
  860.                 $this->instanceof = $instanceof;
  862.                 return new Reference($id);
  863.             }
  864.             if ('abstract' === $value->getTag()) {
  865.                 return new AbstractArgument($value->getValue());
  866.             }
  868.             throw new InvalidArgumentException(sprintf('Unsupported tag "!%s".', $value->getTag()));
  869.         }
  871.         if (\is_array($value)) {
  872.             foreach ($value as $k => $v) {
  873.                 $value[$k] = $this->resolveServices($v, $file, $isParameter);
  874.             }
  875.         } elseif (\is_string($value) && str_starts_with($value, '@=')) {
  876.             if ($isParameter) {
  877.                 throw new InvalidArgumentException(sprintf('Using expressions in parameters is not allowed in "%s".', $file));
  878.             }
  880.             if (!class_exists(Expression::class)) {
  881.                 throw new \LogicException('The "@=" expression syntax cannot be used without the ExpressionLanguage component. Try running "composer require symfony/expression-language".');
  882.             }
  884.             return new Expression(substr($value, 2));
  885.         } elseif (\is_string($value) && str_starts_with($value, '@')) {
  886.             if (str_starts_with($value, '@@')) {
  887.                 $value = substr($value, 1);
  888.                 $invalidBehavior = null;
  889.             } elseif (str_starts_with($value, '@!')) {
  890.                 $value = substr($value, 2);
  891.                 $invalidBehavior = ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE;
  892.             } elseif (str_starts_with($value, '@?')) {
  893.                 $value = substr($value, 2);
  894.                 $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
  895.             } else {
  896.                 $value = substr($value, 1);
  897.                 $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
  898.             }
  900.             if (null !== $invalidBehavior) {
  901.                 $value = new Reference($value, $invalidBehavior);
  902.             }
  903.         }
  905.         return $value;
  906.     }
  908.     private function loadFromExtensions(array $content)
  909.     {
  910.         foreach ($content as $namespace => $values) {
  911.             if (\in_array($namespace, ['imports', 'parameters', 'services']) || str_starts_with($namespace, 'when@')) {
  912.                 continue;
  913.             }
  915.             if (!\is_array($values) && null !== $values) {
  916.                 $values = [];
  917.             }
  919.             $this->container->loadFromExtension($namespace, $values);
  920.         }
  921.     }
  923.     private function checkDefinition(string $id, array $definition, string $file)
  924.     {
  925.         if ($this->isLoadingInstanceof) {
  926.             $keywords = self::INSTANCEOF_KEYWORDS;
  927.         } elseif (isset($definition['resource']) || isset($definition['namespace'])) {
  928.             $keywords = self::PROTOTYPE_KEYWORDS;
  929.         } else {
  930.             $keywords = self::SERVICE_KEYWORDS;
  931.         }
  933.         foreach ($definition as $key => $value) {
  934.             if (!isset($keywords[$key])) {
  935.                 throw new InvalidArgumentException(sprintf('The configuration key "%s" is unsupported for definition "%s" in "%s". Allowed configuration keys are "%s".', $key, $id, $file, implode('", "', $keywords)));
  936.             }
  937.         }
  938.     }
  940.     private function validateAttributes(string $message, array $attributes, array $path = []): void
  941.     {
  942.         foreach ($attributes as $name => $value) {
  943.             if (\is_array($value)) {
  944.                 $this->validateAttributes($message, $value, [...$path, $name]);
  945.             } elseif (!\is_scalar($value ?? '')) {
  946.                 $name = implode('.', [...$path, $name]);
  947.                 throw new InvalidArgumentException(sprintf($message, $name));
  948.             }
  949.         }
  950.     }
  951. }