vendor/symfony/symfony/src/Symfony/Component/DependencyInjection/Loader/YamlFileLoader.php line 789

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\DependencyInjection\Alias;
  15. use Symfony\Component\DependencyInjection\Argument\ArgumentInterface;
  16. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  17. use Symfony\Component\DependencyInjection\ChildDefinition;
  18. use Symfony\Component\DependencyInjection\ContainerInterface;
  19. use Symfony\Component\DependencyInjection\Definition;
  20. use Symfony\Component\DependencyInjection\Reference;
  21. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  22. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  23. use Symfony\Component\Yaml\Exception\ParseException;
  24. use Symfony\Component\Yaml\Parser as YamlParser;
  25. use Symfony\Component\Yaml\Tag\TaggedValue;
  26. use Symfony\Component\Yaml\Yaml;
  27. use Symfony\Component\ExpressionLanguage\Expression;
  29. /**
  30.  * YamlFileLoader loads YAML files service definitions.
  31.  *
  32.  * @author Fabien Potencier <fabien@symfony.com>
  33.  */
  34. class YamlFileLoader extends FileLoader
  35. {
  36.     private static $serviceKeywords = array(
  37.         'alias' => 'alias',
  38.         'parent' => 'parent',
  39.         'class' => 'class',
  40.         'shared' => 'shared',
  41.         'synthetic' => 'synthetic',
  42.         'lazy' => 'lazy',
  43.         'public' => 'public',
  44.         'abstract' => 'abstract',
  45.         'deprecated' => 'deprecated',
  46.         'factory' => 'factory',
  47.         'file' => 'file',
  48.         'arguments' => 'arguments',
  49.         'properties' => 'properties',
  50.         'configurator' => 'configurator',
  51.         'calls' => 'calls',
  52.         'tags' => 'tags',
  53.         'decorates' => 'decorates',
  54.         'decoration_inner_name' => 'decoration_inner_name',
  55.         'decoration_priority' => 'decoration_priority',
  56.         'autowire' => 'autowire',
  57.         'autowiring_types' => 'autowiring_types',
  58.         'autoconfigure' => 'autoconfigure',
  59.     );
  61.     private static $prototypeKeywords = array(
  62.         'resource' => 'resource',
  63.         'exclude' => 'exclude',
  64.         'parent' => 'parent',
  65.         'shared' => 'shared',
  66.         'lazy' => 'lazy',
  67.         'public' => 'public',
  68.         'abstract' => 'abstract',
  69.         'deprecated' => 'deprecated',
  70.         'factory' => 'factory',
  71.         'arguments' => 'arguments',
  72.         'properties' => 'properties',
  73.         'configurator' => 'configurator',
  74.         'calls' => 'calls',
  75.         'tags' => 'tags',
  76.         'autowire' => 'autowire',
  77.         'autoconfigure' => 'autoconfigure',
  78.     );
  80.     private static $instanceofKeywords = array(
  81.         'shared' => 'shared',
  82.         'lazy' => 'lazy',
  83.         'public' => 'public',
  84.         'properties' => 'properties',
  85.         'configurator' => 'configurator',
  86.         'calls' => 'calls',
  87.         'tags' => 'tags',
  88.         'autowire' => 'autowire',
  89.     );
  91.     private static $defaultsKeywords = array(
  92.         'public' => 'public',
  93.         'tags' => 'tags',
  94.         'autowire' => 'autowire',
  95.         'autoconfigure' => 'autoconfigure',
  96.     );
  98.     private $yamlParser;
  100.     private $anonymousServicesCount;
  102.     /**
  103.      * {@inheritdoc}
  104.      */
  105.     public function load($resource, $type = null)
  106.     {
  107.         $path = $this->locator->locate($resource);
  109.         $content = $this->loadFile($path);
  111.         $this->container->fileExists($path);
  113.         // empty file
  114.         if (null === $content) {
  115.             return;
  116.         }
  118.         // imports
  119.         $this->parseImports($content, $path);
  121.         // parameters
  122.         if (isset($content['parameters'])) {
  123.             if (!is_array($content['parameters'])) {
  124.                 throw new InvalidArgumentException(sprintf('The "parameters" key should contain an array in %s. Check your YAML syntax.', $path));
  125.             }
  127.             foreach ($content['parameters'] as $key => $value) {
  128.                 $this->container->setParameter($key, $this->resolveServices($value, $path, true));
  129.             }
  130.         }
  132.         // extensions
  133.         $this->loadFromExtensions($content);
  135.         // services
  136.         $this->anonymousServicesCount = 0;
  137.         $this->setCurrentDir(dirname($path));
  138.         try {
  139.             $this->parseDefinitions($content, $path);
  140.         } finally {
  141.             $this->instanceof = array();
  142.         }
  143.     }
  145.     /**
  146.      * {@inheritdoc}
  147.      */
  148.     public function supports($resource, $type = null)
  149.     {
  150.         if (!is_string($resource)) {
  151.             return false;
  152.         }
  154.         if (null === $type && in_array(pathinfo($resource, PATHINFO_EXTENSION), array('yaml', 'yml'), true)) {
  155.             return true;
  156.         }
  158.         return in_array($type, array('yaml', 'yml'), true);
  159.     }
  161.     /**
  162.      * Parses all imports.
  163.      *
  164.      * @param array  $content
  165.      * @param string $file
  166.      */
  167.     private function parseImports(array $content, $file)
  168.     {
  169.         if (!isset($content['imports'])) {
  170.             return;
  171.         }
  173.         if (!is_array($content['imports'])) {
  174.             throw new InvalidArgumentException(sprintf('The "imports" key should contain an array in %s. Check your YAML syntax.', $file));
  175.         }
  177.         $defaultDirectory = dirname($file);
  178.         foreach ($content['imports'] as $import) {
  179.             if (!is_array($import)) {
  180.                 throw new InvalidArgumentException(sprintf('The values in the "imports" key should be arrays in %s. Check your YAML syntax.', $file));
  181.             }
  183.             $this->setCurrentDir($defaultDirectory);
  184.             $this->import($import['resource'], isset($import['type']) ? $import['type'] : null, isset($import['ignore_errors']) ? (bool) $import['ignore_errors'] : false, $file);
  185.         }
  186.     }
  188.     /**
  189.      * Parses definitions.
  190.      *
  191.      * @param array  $content
  192.      * @param string $file
  193.      */
  194.     private function parseDefinitions(array $content, $file)
  195.     {
  196.         if (!isset($content['services'])) {
  197.             return;
  198.         }
  200.         if (!is_array($content['services'])) {
  201.             throw new InvalidArgumentException(sprintf('The "services" key should contain an array in %s. Check your YAML syntax.', $file));
  202.         }
  204.         if (array_key_exists('_instanceof', $content['services'])) {
  205.             $instanceof = $content['services']['_instanceof'];
  206.             unset($content['services']['_instanceof']);
  208.             if (!is_array($instanceof)) {
  209.                 throw new InvalidArgumentException(sprintf('Service "_instanceof" key must be an array, "%s" given in "%s".', gettype($instanceof), $file));
  210.             }
  211.             $this->instanceof = array();
  212.             $this->isLoadingInstanceof = true;
  213.             foreach ($instanceof as $id => $service) {
  214.                 if (!$service || !is_array($service)) {
  215.                     throw new InvalidArgumentException(sprintf('Type definition "%s" must be a non-empty array within "_instanceof" in %s. Check your YAML syntax.', $id, $file));
  216.                 }
  217.                 if (is_string($service) && 0 === strpos($service, '@')) {
  218.                     throw new InvalidArgumentException(sprintf('Type definition "%s" cannot be an alias within "_instanceof" in %s. Check your YAML syntax.', $id, $file));
  219.                 }
  220.                 $this->parseDefinition($id, $service, $file, array());
  221.             }
  222.         }
  224.         $this->isLoadingInstanceof = false;
  225.         $defaults = $this->parseDefaults($content, $file);
  226.         foreach ($content['services'] as $id => $service) {
  227.             $this->parseDefinition($id, $service, $file, $defaults);
  228.         }
  229.     }
  231.     /**
  232.      * @param array  $content
  233.      * @param string $file
  234.      *
  235.      * @return array
  236.      *
  237.      * @throws InvalidArgumentException
  238.      */
  239.     private function parseDefaults(array &$content, $file)
  240.     {
  241.         if (!array_key_exists('_defaults', $content['services'])) {
  242.             return array();
  243.         }
  244.         $defaults = $content['services']['_defaults'];
  245.         unset($content['services']['_defaults']);
  247.         if (!is_array($defaults)) {
  248.             throw new InvalidArgumentException(sprintf('Service "_defaults" key must be an array, "%s" given in "%s".', gettype($defaults), $file));
  249.         }
  251.         foreach ($defaults as $key => $default) {
  252.             if (!isset(self::$defaultsKeywords[$key])) {
  253.                 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::$defaultsKeywords)));
  254.             }
  255.         }
  256.         if (!isset($defaults['tags'])) {
  257.             return $defaults;
  258.         }
  259.         if (!is_array($tags = $defaults['tags'])) {
  260.             throw new InvalidArgumentException(sprintf('Parameter "tags" in "_defaults" must be an array in %s. Check your YAML syntax.', $file));
  261.         }
  263.         foreach ($tags as $tag) {
  264.             if (!is_array($tag)) {
  265.                 $tag = array('name' => $tag);
  266.             }
  268.             if (!isset($tag['name'])) {
  269.                 throw new InvalidArgumentException(sprintf('A "tags" entry in "_defaults" is missing a "name" key in %s.', $file));
  270.             }
  271.             $name = $tag['name'];
  272.             unset($tag['name']);
  274.             if (!is_string($name) || '' === $name) {
  275.                 throw new InvalidArgumentException(sprintf('The tag name in "_defaults" must be a non-empty string in %s.', $file));
  276.             }
  278.             foreach ($tag as $attribute => $value) {
  279.                 if (!is_scalar($value) && null !== $value) {
  280.                     throw new InvalidArgumentException(sprintf('Tag "%s", attribute "%s" in "_defaults" must be of a scalar-type in %s. Check your YAML syntax.', $name, $attribute, $file));
  281.                 }
  282.             }
  283.         }
  285.         return $defaults;
  286.     }
  288.     /**
  289.      * @param array $service
  290.      *
  291.      * @return bool
  292.      */
  293.     private function isUsingShortSyntax(array $service)
  294.     {
  295.         foreach ($service as $key => $value) {
  296.             if (is_string($key) && ('' === $key || '$' !== $key[0])) {
  297.                 return false;
  298.             }
  299.         }
  301.         return true;
  302.     }
  304.     /**
  305.      * Parses a definition.
  306.      *
  307.      * @param string       $id
  308.      * @param array|string $service
  309.      * @param string       $file
  310.      * @param array        $defaults
  311.      *
  312.      * @throws InvalidArgumentException When tags are invalid
  313.      */
  314.     private function parseDefinition($id, $service, $file, array $defaults)
  315.     {
  316.         if (preg_match('/^_[a-zA-Z0-9_]*$/', $id)) {
  317.             @trigger_error(sprintf('Service names that start with an underscore are deprecated since Symfony 3.3 and will be reserved in 4.0. Rename the "%s" service or define it in XML instead.', $id), E_USER_DEPRECATED);
  318.         }
  319.         if (is_string($service) && 0 === strpos($service, '@')) {
  320.             $public = isset($defaults['public']) ? $defaults['public'] : true;
  321.             $this->container->setAlias($id, new Alias(substr($service, 1), $public));
  323.             return;
  324.         }
  326.         if (is_array($service) && $this->isUsingShortSyntax($service)) {
  327.             $service = array('arguments' => $service);
  328.         }
  330.         if (null === $service) {
  331.             $service = array();
  332.         }
  334.         if (!is_array($service)) {
  335.             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.', gettype($service), $id, $file));
  336.         }
  338.         $this->checkDefinition($id, $service, $file);
  340.         if (isset($service['alias'])) {
  341.             $public = array_key_exists('public', $service) ? (bool) $service['public'] : (isset($defaults['public']) ? $defaults['public'] : true);
  342.             $this->container->setAlias($id, new Alias($service['alias'], $public));
  344.             foreach ($service as $key => $value) {
  345.                 if (!in_array($key, array('alias', 'public'))) {
  346.                     @trigger_error(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" and "public". The YamlFileLoader will raise an exception in Symfony 4.0, instead of silently ignoring unsupported attributes.', $key, $id, $file), E_USER_DEPRECATED);
  347.                 }
  348.             }
  350.             return;
  351.         }
  353.         if ($this->isLoadingInstanceof) {
  354.             $definition = new ChildDefinition('');
  355.         } elseif (isset($service['parent'])) {
  356.             if (!empty($this->instanceof)) {
  357.                 throw new InvalidArgumentException(sprintf('The service "%s" cannot use the "parent" option in the same file where "_instanceof" configuration is defined as using both is not supported. Move your child definitions to a separate file.', $id));
  358.             }
  360.             foreach ($defaults as $k => $v) {
  361.                 if ('tags' === $k) {
  362.                     // since tags are never inherited from parents, there is no confusion
  363.                     // thus we can safely add them as defaults to ChildDefinition
  364.                     continue;
  365.                 }
  366.                 if (!isset($service[$k])) {
  367.                     throw new InvalidArgumentException(sprintf('Attribute "%s" on service "%s" cannot be inherited from "_defaults" when a "parent" is set. Move your child definitions to a separate file or define this attribute explicitly.', $k, $id));
  368.                 }
  369.             }
  371.             $definition = new ChildDefinition($service['parent']);
  372.         } else {
  373.             $definition = new Definition();
  375.             if (isset($defaults['public'])) {
  376.                 $definition->setPublic($defaults['public']);
  377.             }
  378.             if (isset($defaults['autowire'])) {
  379.                 $definition->setAutowired($defaults['autowire']);
  380.             }
  381.             if (isset($defaults['autoconfigure'])) {
  382.                 $definition->setAutoconfigured($defaults['autoconfigure']);
  383.             }
  385.             $definition->setChanges(array());
  386.         }
  388.         if (isset($service['class'])) {
  389.             $definition->setClass($service['class']);
  390.         }
  392.         if (isset($service['shared'])) {
  393.             $definition->setShared($service['shared']);
  394.         }
  396.         if (isset($service['synthetic'])) {
  397.             $definition->setSynthetic($service['synthetic']);
  398.         }
  400.         if (isset($service['lazy'])) {
  401.             $definition->setLazy($service['lazy']);
  402.         }
  404.         if (isset($service['public'])) {
  405.             $definition->setPublic($service['public']);
  406.         }
  408.         if (isset($service['abstract'])) {
  409.             $definition->setAbstract($service['abstract']);
  410.         }
  412.         if (array_key_exists('deprecated', $service)) {
  413.             $definition->setDeprecated(true, $service['deprecated']);
  414.         }
  416.         if (isset($service['factory'])) {
  417.             $definition->setFactory($this->parseCallable($service['factory'], 'factory', $id, $file));
  418.         }
  420.         if (isset($service['file'])) {
  421.             $definition->setFile($service['file']);
  422.         }
  424.         if (isset($service['arguments'])) {
  425.             $definition->setArguments($this->resolveServices($service['arguments'], $file));
  426.         }
  428.         if (isset($service['properties'])) {
  429.             $definition->setProperties($this->resolveServices($service['properties'], $file));
  430.         }
  432.         if (isset($service['configurator'])) {
  433.             $definition->setConfigurator($this->parseCallable($service['configurator'], 'configurator', $id, $file));
  434.         }
  436.         if (isset($service['calls'])) {
  437.             if (!is_array($service['calls'])) {
  438.                 throw new InvalidArgumentException(sprintf('Parameter "calls" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
  439.             }
  441.             foreach ($service['calls'] as $call) {
  442.                 if (isset($call['method'])) {
  443.                     $method = $call['method'];
  444.                     $args = isset($call['arguments']) ? $this->resolveServices($call['arguments'], $file) : array();
  445.                 } else {
  446.                     $method = $call[0];
  447.                     $args = isset($call[1]) ? $this->resolveServices($call[1], $file) : array();
  448.                 }
  450.                 $definition->addMethodCall($method, $args);
  451.             }
  452.         }
  454.         $tags = isset($service['tags']) ? $service['tags'] : array();
  455.         if (!is_array($tags)) {
  456.             throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
  457.         }
  459.         if (isset($defaults['tags'])) {
  460.             $tags = array_merge($tags, $defaults['tags']);
  461.         }
  463.         foreach ($tags as $tag) {
  464.             if (!is_array($tag)) {
  465.                 $tag = array('name' => $tag);
  466.             }
  468.             if (!isset($tag['name'])) {
  469.                 throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file));
  470.             }
  471.             $name = $tag['name'];
  472.             unset($tag['name']);
  474.             if (!is_string($name) || '' === $name) {
  475.                 throw new InvalidArgumentException(sprintf('The tag name for service "%s" in %s must be a non-empty string.', $id, $file));
  476.             }
  478.             foreach ($tag as $attribute => $value) {
  479.                 if (!is_scalar($value) && null !== $value) {
  480.                     throw new InvalidArgumentException(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, $attribute, $file));
  481.                 }
  482.             }
  484.             $definition->addTag($name, $tag);
  485.         }
  487.         if (isset($service['decorates'])) {
  488.             if ('' !== $service['decorates'] && '@' === $service['decorates'][0]) {
  489.                 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($service['decorates'], 1)));
  490.             }
  492.             $renameId = isset($service['decoration_inner_name']) ? $service['decoration_inner_name'] : null;
  493.             $priority = isset($service['decoration_priority']) ? $service['decoration_priority'] : 0;
  494.             $definition->setDecoratedService($service['decorates'], $renameId, $priority);
  495.         }
  497.         if (isset($service['autowire'])) {
  498.             $definition->setAutowired($service['autowire']);
  499.         }
  501.         if (isset($service['autowiring_types'])) {
  502.             if (is_string($service['autowiring_types'])) {
  503.                 $definition->addAutowiringType($service['autowiring_types']);
  504.             } else {
  505.                 if (!is_array($service['autowiring_types'])) {
  506.                     throw new InvalidArgumentException(sprintf('Parameter "autowiring_types" must be a string or an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
  507.                 }
  509.                 foreach ($service['autowiring_types'] as $autowiringType) {
  510.                     if (!is_string($autowiringType)) {
  511.                         throw new InvalidArgumentException(sprintf('A "autowiring_types" attribute must be of type string for service "%s" in %s. Check your YAML syntax.', $id, $file));
  512.                     }
  514.                     $definition->addAutowiringType($autowiringType);
  515.                 }
  516.             }
  517.         }
  519.         if (isset($service['autoconfigure'])) {
  520.             if (!$definition instanceof ChildDefinition) {
  521.                 $definition->setAutoconfigured($service['autoconfigure']);
  522.             } elseif ($service['autoconfigure']) {
  523.                 throw new InvalidArgumentException(sprintf('The service "%s" cannot have a "parent" and also have "autoconfigure". Try setting "autoconfigure: false" for the service.', $id));
  524.             }
  525.         }
  527.         if (array_key_exists('resource', $service)) {
  528.             if (!is_string($service['resource'])) {
  529.                 throw new InvalidArgumentException(sprintf('A "resource" attribute must be of type string for service "%s" in %s. Check your YAML syntax.', $id, $file));
  530.             }
  531.             $exclude = isset($service['exclude']) ? $service['exclude'] : null;
  532.             $this->registerClasses($definition, $id, $service['resource'], $exclude);
  533.         } else {
  534.             $this->setDefinition($id, $definition);
  535.         }
  536.     }
  538.     /**
  539.      * Parses a callable.
  540.      *
  541.      * @param string|array $callable  A callable
  542.      * @param string       $parameter A parameter (e.g. 'factory' or 'configurator')
  543.      * @param string       $id        A service identifier
  544.      * @param string       $file      A parsed file
  545.      *
  546.      * @throws InvalidArgumentException When errors are occuried
  547.      *
  548.      * @return string|array A parsed callable
  549.      */
  550.     private function parseCallable($callable, $parameter, $id, $file)
  551.     {
  552.         if (is_string($callable)) {
  553.             if ('' !== $callable && '@' === $callable[0]) {
  554.                 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").', $parameter, $id, $callable, substr($callable, 1)));
  555.             }
  557.             if (false !== strpos($callable, ':') && false === strpos($callable, '::')) {
  558.                 $parts = explode(':', $callable);
  560.                 return array($this->resolveServices('@'.$parts[0], $file), $parts[1]);
  561.             }
  563.             return $callable;
  564.         }
  566.         if (is_array($callable)) {
  567.             if (isset($callable[0]) && isset($callable[1])) {
  568.                 return array($this->resolveServices($callable[0], $file), $callable[1]);
  569.             }
  571.             if ('factory' === $parameter && isset($callable[1]) && null === $callable[0]) {
  572.                 return $callable;
  573.             }
  575.             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));
  576.         }
  578.         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));
  579.     }
  581.     /**
  582.      * Loads a YAML file.
  583.      *
  584.      * @param string $file
  585.      *
  586.      * @return array The file content
  587.      *
  588.      * @throws InvalidArgumentException when the given file is not a local file or when it does not exist
  589.      */
  590.     protected function loadFile($file)
  591.     {
  592.         if (!class_exists('Symfony\Component\Yaml\Parser')) {
  593.             throw new RuntimeException('Unable to load YAML config files as the Symfony Yaml Component is not installed.');
  594.         }
  596.         if (!stream_is_local($file)) {
  597.             throw new InvalidArgumentException(sprintf('This is not a local file "%s".', $file));
  598.         }
  600.         if (!file_exists($file)) {
  601.             throw new InvalidArgumentException(sprintf('The file "%s" does not exist.', $file));
  602.         }
  604.         if (null === $this->yamlParser) {
  605.             $this->yamlParser = new YamlParser();
  606.         }
  608.         $prevErrorHandler = set_error_handler(function ($level, $message, $script, $line) use ($file, &$prevErrorHandler) {
  609.             $message = E_USER_DEPRECATED === $level ? preg_replace('/ on line \d+/', ' in "'.$file.'"$0', $message) : $message;
  611.             return $prevErrorHandler ? $prevErrorHandler($level, $message, $script, $line) : false;
  612.         });
  614.         try {
  615.             $configuration = $this->yamlParser->parse(file_get_contents($file), Yaml::PARSE_CONSTANT | Yaml::PARSE_CUSTOM_TAGS | Yaml::PARSE_KEYS_AS_STRINGS);
  616.         } catch (ParseException $e) {
  617.             throw new InvalidArgumentException(sprintf('The file "%s" does not contain valid YAML.', $file), 0, $e);
  618.         } finally {
  619.             restore_error_handler();
  620.         }
  622.         return $this->validate($configuration, $file);
  623.     }
  625.     /**
  626.      * Validates a YAML file.
  627.      *
  628.      * @param mixed  $content
  629.      * @param string $file
  630.      *
  631.      * @return array
  632.      *
  633.      * @throws InvalidArgumentException When service file is not valid
  634.      */
  635.     private function validate($content, $file)
  636.     {
  637.         if (null === $content) {
  638.             return $content;
  639.         }
  641.         if (!is_array($content)) {
  642.             throw new InvalidArgumentException(sprintf('The service file "%s" is not valid. It should contain an array. Check your YAML syntax.', $file));
  643.         }
  645.         foreach ($content as $namespace => $data) {
  646.             if (in_array($namespace, array('imports', 'parameters', 'services'))) {
  647.                 continue;
  648.             }
  650.             if (!$this->container->hasExtension($namespace)) {
  651.                 $extensionNamespaces = array_filter(array_map(function ($ext) { return $ext->getAlias(); }, $this->container->getExtensions()));
  652.                 throw new InvalidArgumentException(sprintf(
  653.                     'There is no extension able to load the configuration for "%s" (in %s). Looked for namespace "%s", found %s',
  654.                     $namespace,
  655.                     $file,
  656.                     $namespace,
  657.                     $extensionNamespaces ? sprintf('"%s"', implode('", "', $extensionNamespaces)) : 'none'
  658.                 ));
  659.             }
  660.         }
  662.         return $content;
  663.     }
  665.     /**
  666.      * Resolves services.
  667.      *
  668.      * @param mixed  $value
  669.      * @param string $file
  670.      * @param bool   $isParameter
  671.      *
  672.      * @return array|string|Reference|ArgumentInterface
  673.      */
  674.     private function resolveServices($value, $file, $isParameter = false)
  675.     {
  676.         if ($value instanceof TaggedValue) {
  677.             $argument = $value->getValue();
  678.             if ('iterator' === $value->getTag()) {
  679.                 if (!is_array($argument)) {
  680.                     throw new InvalidArgumentException(sprintf('"!iterator" tag only accepts sequences in "%s".', $file));
  681.                 }
  682.                 $argument = $this->resolveServices($argument, $file, $isParameter);
  683.                 try {
  684.                     return new IteratorArgument($argument);
  685.                 } catch (InvalidArgumentException $e) {
  686.                     throw new InvalidArgumentException(sprintf('"!iterator" tag only accepts arrays of "@service" references in "%s".', $file));
  687.                 }
  688.             }
  689.             if ('service' === $value->getTag()) {
  690.                 if ($isParameter) {
  691.                     throw new InvalidArgumentException(sprintf('Using an anonymous service in a parameter is not allowed in "%s".', $file));
  692.                 }
  694.                 $isLoadingInstanceof = $this->isLoadingInstanceof;
  695.                 $this->isLoadingInstanceof = false;
  696.                 $instanceof = $this->instanceof;
  697.                 $this->instanceof = array();
  699.                 $id = sprintf('%d_%s', ++$this->anonymousServicesCount, hash('sha256', $file));
  700.                 $this->parseDefinition($id, $argument, $file, array());
  702.                 if (!$this->container->hasDefinition($id)) {
  703.                     throw new InvalidArgumentException(sprintf('Creating an alias using the tag "!service" is not allowed in "%s".', $file));
  704.                 }
  706.                 $this->container->getDefinition($id)->setPublic(false);
  708.                 $this->isLoadingInstanceof = $isLoadingInstanceof;
  709.                 $this->instanceof = $instanceof;
  711.                 return new Reference($id);
  712.             }
  714.             throw new InvalidArgumentException(sprintf('Unsupported tag "!%s".', $value->getTag()));
  715.         }
  717.         if (is_array($value)) {
  718.             foreach ($value as $k => $v) {
  719.                 $value[$k] = $this->resolveServices($v, $file, $isParameter);
  720.             }
  721.         } elseif (is_string($value) && 0 === strpos($value, '@=')) {
  722.             return new Expression(substr($value, 2));
  723.         } elseif (is_string($value) && 0 === strpos($value, '@')) {
  724.             if (0 === strpos($value, '@@')) {
  725.                 $value = substr($value, 1);
  726.                 $invalidBehavior = null;
  727.             } elseif (0 === strpos($value, '@?')) {
  728.                 $value = substr($value, 2);
  729.                 $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
  730.             } else {
  731.                 $value = substr($value, 1);
  732.                 $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
  733.             }
  735.             if ('=' === substr($value, -1)) {
  736.                 @trigger_error(sprintf('The "=" suffix that used to disable strict references in Symfony 2.x is deprecated since Symfony 3.3 and will be unsupported in 4.0. Remove it in "%s".', $value), E_USER_DEPRECATED);
  737.                 $value = substr($value, 0, -1);
  738.             }
  740.             if (null !== $invalidBehavior) {
  741.                 $value = new Reference($value, $invalidBehavior);
  742.             }
  743.         }
  745.         return $value;
  746.     }
  748.     /**
  749.      * Loads from Extensions.
  750.      */
  751.     private function loadFromExtensions(array $content)
  752.     {
  753.         foreach ($content as $namespace => $values) {
  754.             if (in_array($namespace, array('imports', 'parameters', 'services'))) {
  755.                 continue;
  756.             }
  758.             if (!is_array($values) && null !== $values) {
  759.                 $values = array();
  760.             }
  762.             $this->container->loadFromExtension($namespace, $values);
  763.         }
  764.     }
  766.     /**
  767.      * Checks the keywords used to define a service.
  768.      *
  769.      * @param string $id         The service name
  770.      * @param array  $definition The service definition to check
  771.      * @param string $file       The loaded YAML file
  772.      */
  773.     private function checkDefinition($id, array $definition, $file)
  774.     {
  775.         if ($throw = $this->isLoadingInstanceof) {
  776.             $keywords = self::$instanceofKeywords;
  777.         } elseif ($throw = isset($definition['resource'])) {
  778.             $keywords = self::$prototypeKeywords;
  779.         } else {
  780.             $keywords = self::$serviceKeywords;
  781.         }
  783.         foreach ($definition as $key => $value) {
  784.             if (!isset($keywords[$key])) {
  785.                 if ($throw) {
  786.                     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)));
  787.                 }
  789.                 @trigger_error(sprintf('The configuration key "%s" is unsupported for service definition "%s" in "%s". Allowed configuration keys are "%s". The YamlFileLoader object will raise an exception instead in Symfony 4.0 when detecting an unsupported service configuration key.', $key, $id, $file, implode('", "', $keywords)), E_USER_DEPRECATED);
  790.             }
  791.         }
  792.     }
  793. }