Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
0.00% |
0 / 7 |
CRAP | |
0.00% |
0 / 201 |
| YamlFileLoader | |
0.00% |
0 / 1 |
|
0.00% |
0 / 7 |
4970 | |
0.00% |
0 / 201 |
| __construct | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 4 |
|||
| load | |
0.00% |
0 / 1 |
42 | |
0.00% |
0 / 19 |
|||
| parseDefinitions | |
0.00% |
0 / 1 |
20 | |
0.00% |
0 / 11 |
|||
| parseDefinition | |
0.00% |
0 / 1 |
1806 | |
0.00% |
0 / 118 |
|||
| loadFile | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 9 |
|||
| validate | |
0.00% |
0 / 1 |
20 | |
0.00% |
0 / 12 |
|||
| resolveServices | |
0.00% |
0 / 1 |
110 | |
0.00% |
0 / 28 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\Core\DependencyInjection\YamlFileLoader. | |
| */ | |
| namespace Drupal\Core\DependencyInjection; | |
| use Drupal\Component\FileCache\FileCacheFactory; | |
| use Drupal\Component\Serialization\Yaml; | |
| use Symfony\Component\DependencyInjection\Alias; | |
| use Symfony\Component\DependencyInjection\ContainerInterface; | |
| use Symfony\Component\DependencyInjection\Definition; | |
| use Symfony\Component\DependencyInjection\DefinitionDecorator; | |
| use Symfony\Component\DependencyInjection\Reference; | |
| use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException; | |
| /** | |
| * YamlFileLoader loads YAML files service definitions. | |
| * | |
| * Drupal does not use Symfony's Config component, and Symfony's dependency on | |
| * it cannot be removed easily. Therefore, this is a partial but mostly literal | |
| * copy of upstream, which does not depend on the Config component. | |
| * | |
| * @see \Symfony\Component\DependencyInjection\Loader\YamlFileLoader | |
| * @see https://github.com/symfony/symfony/pull/10920 | |
| * | |
| * NOTE: 98% of this code is a literal copy of Symfony's YamlFileLoader. | |
| * | |
| * This file does NOT follow Drupal coding standards, so as to simplify future | |
| * synchronizations. | |
| */ | |
| class YamlFileLoader | |
| { | |
| /** | |
| * @var \Drupal\Core\DependencyInjection\ContainerBuilder $container | |
| */ | |
| protected $container; | |
| /** | |
| * File cache object. | |
| * | |
| * @var \Drupal\Component\FileCache\FileCacheInterface | |
| */ | |
| protected $fileCache; | |
| public function __construct(ContainerBuilder $container) | |
| { | |
| $this->container = $container; | |
| $this->fileCache = FileCacheFactory::get('container_yaml_loader'); | |
| } | |
| /** | |
| * Loads a Yaml file. | |
| * | |
| * @param mixed $file The resource | |
| */ | |
| public function load($file) | |
| { | |
| // Load from the file cache, fall back to loading the file. | |
| // @todo Refactor this to cache parsed definition objects in | |
| // https://www.drupal.org/node/2464053 | |
| $content = $this->fileCache->get($file); | |
| if (!$content) { | |
| $content = $this->loadFile($file); | |
| $this->fileCache->set($file, $content); | |
| } | |
| // Not supported. | |
| //$this->container->addResource(new FileResource($path)); | |
| // empty file | |
| if (null === $content) { | |
| return; | |
| } | |
| // imports | |
| // Not supported. | |
| //$this->parseImports($content, $file); | |
| // parameters | |
| if (isset($content['parameters'])) { | |
| if (!is_array($content['parameters'])) { | |
| throw new InvalidArgumentException(sprintf('The "parameters" key should contain an array in %s. Check your YAML syntax.', $file)); | |
| } | |
| foreach ($content['parameters'] as $key => $value) { | |
| $this->container->setParameter($key, $this->resolveServices($value)); | |
| } | |
| } | |
| // extensions | |
| // Not supported. | |
| //$this->loadFromExtensions($content); | |
| // services | |
| $this->parseDefinitions($content, $file); | |
| } | |
| /** | |
| * Parses definitions | |
| * | |
| * @param array $content | |
| * @param string $file | |
| */ | |
| private function parseDefinitions($content, $file) | |
| { | |
| if (!isset($content['services'])) { | |
| return; | |
| } | |
| if (!is_array($content['services'])) { | |
| throw new InvalidArgumentException(sprintf('The "services" key should contain an array in %s. Check your YAML syntax.', $file)); | |
| } | |
| foreach ($content['services'] as $id => $service) { | |
| $this->parseDefinition($id, $service, $file); | |
| } | |
| } | |
| /** | |
| * Parses a definition. | |
| * | |
| * @param string $id | |
| * @param array $service | |
| * @param string $file | |
| * | |
| * @throws InvalidArgumentException When tags are invalid | |
| */ | |
| private function parseDefinition($id, $service, $file) | |
| { | |
| if (is_string($service) && 0 === strpos($service, '@')) { | |
| $this->container->setAlias($id, substr($service, 1)); | |
| return; | |
| } | |
| if (!is_array($service)) { | |
| 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)); | |
| } | |
| if (isset($service['alias'])) { | |
| $public = !array_key_exists('public', $service) || (bool) $service['public']; | |
| $this->container->setAlias($id, new Alias($service['alias'], $public)); | |
| return; | |
| } | |
| if (isset($service['parent'])) { | |
| $definition = new DefinitionDecorator($service['parent']); | |
| } else { | |
| $definition = new Definition(); | |
| } | |
| if (isset($service['class'])) { | |
| $definition->setClass($service['class']); | |
| } | |
| if (isset($service['scope'])) { | |
| $definition->setScope($service['scope']); | |
| } | |
| if (isset($service['synthetic'])) { | |
| $definition->setSynthetic($service['synthetic']); | |
| } | |
| if (isset($service['synchronized'])) { | |
| $definition->setSynchronized($service['synchronized'], 'request' !== $id); | |
| } | |
| if (isset($service['lazy'])) { | |
| $definition->setLazy($service['lazy']); | |
| } | |
| if (isset($service['public'])) { | |
| $definition->setPublic($service['public']); | |
| } | |
| if (isset($service['abstract'])) { | |
| $definition->setAbstract($service['abstract']); | |
| } | |
| if (isset($service['factory'])) { | |
| if (is_string($service['factory'])) { | |
| if (strpos($service['factory'], ':') !== false && strpos($service['factory'], '::') === false) { | |
| $parts = explode(':', $service['factory']); | |
| $definition->setFactory(array($this->resolveServices('@'.$parts[0]), $parts[1])); | |
| } else { | |
| $definition->setFactory($service['factory']); | |
| } | |
| } else { | |
| $definition->setFactory(array($this->resolveServices($service['factory'][0]), $service['factory'][1])); | |
| } | |
| } | |
| if (isset($service['factory_class'])) { | |
| $definition->setFactoryClass($service['factory_class']); | |
| } | |
| if (isset($service['factory_method'])) { | |
| $definition->setFactoryMethod($service['factory_method']); | |
| } | |
| if (isset($service['factory_service'])) { | |
| $definition->setFactoryService($service['factory_service']); | |
| } | |
| if (isset($service['file'])) { | |
| $definition->setFile($service['file']); | |
| } | |
| if (isset($service['arguments'])) { | |
| $definition->setArguments($this->resolveServices($service['arguments'])); | |
| } | |
| if (isset($service['properties'])) { | |
| $definition->setProperties($this->resolveServices($service['properties'])); | |
| } | |
| if (isset($service['configurator'])) { | |
| if (is_string($service['configurator'])) { | |
| $definition->setConfigurator($service['configurator']); | |
| } else { | |
| $definition->setConfigurator(array($this->resolveServices($service['configurator'][0]), $service['configurator'][1])); | |
| } | |
| } | |
| if (isset($service['calls'])) { | |
| if (!is_array($service['calls'])) { | |
| throw new InvalidArgumentException(sprintf('Parameter "calls" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file)); | |
| } | |
| foreach ($service['calls'] as $call) { | |
| if (isset($call['method'])) { | |
| $method = $call['method']; | |
| $args = isset($call['arguments']) ? $this->resolveServices($call['arguments']) : array(); | |
| } else { | |
| $method = $call[0]; | |
| $args = isset($call[1]) ? $this->resolveServices($call[1]) : array(); | |
| } | |
| $definition->addMethodCall($method, $args); | |
| } | |
| } | |
| if (isset($service['tags'])) { | |
| if (!is_array($service['tags'])) { | |
| throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file)); | |
| } | |
| foreach ($service['tags'] as $tag) { | |
| if (!is_array($tag)) { | |
| throw new InvalidArgumentException(sprintf('A "tags" entry must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file)); | |
| } | |
| if (!isset($tag['name'])) { | |
| throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file)); | |
| } | |
| $name = $tag['name']; | |
| unset($tag['name']); | |
| foreach ($tag as $attribute => $value) { | |
| if (!is_scalar($value) && null !== $value) { | |
| 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)); | |
| } | |
| } | |
| $definition->addTag($name, $tag); | |
| } | |
| } | |
| if (isset($service['decorates'])) { | |
| $renameId = isset($service['decoration_inner_name']) ? $service['decoration_inner_name'] : null; | |
| $definition->setDecoratedService($service['decorates'], $renameId); | |
| } | |
| $this->container->setDefinition($id, $definition); | |
| } | |
| /** | |
| * Loads a YAML file. | |
| * | |
| * @param string $file | |
| * | |
| * @return array The file content | |
| * | |
| * @throws InvalidArgumentException when the given file is not a local file or when it does not exist | |
| */ | |
| protected function loadFile($file) | |
| { | |
| if (!stream_is_local($file)) { | |
| throw new InvalidArgumentException(sprintf('This is not a local file "%s".', $file)); | |
| } | |
| if (!file_exists($file)) { | |
| throw new InvalidArgumentException(sprintf('The service file "%s" is not valid.', $file)); | |
| } | |
| return $this->validate(Yaml::decode(file_get_contents($file)), $file); | |
| } | |
| /** | |
| * Validates a YAML file. | |
| * | |
| * @param mixed $content | |
| * @param string $file | |
| * | |
| * @return array | |
| * | |
| * @throws InvalidArgumentException When service file is not valid | |
| */ | |
| private function validate($content, $file) | |
| { | |
| if (null === $content) { | |
| return $content; | |
| } | |
| if (!is_array($content)) { | |
| throw new InvalidArgumentException(sprintf('The service file "%s" is not valid. It should contain an array. Check your YAML syntax.', $file)); | |
| } | |
| if ($invalid_keys = array_diff_key($content, array('parameters' => 1, 'services' => 1))) { | |
| throw new InvalidArgumentException(sprintf('The service file "%s" is not valid: it contains invalid keys %s. Services have to be added under "services" and Parameters under "parameters".', $file, $invalid_keys)); | |
| } | |
| return $content; | |
| } | |
| /** | |
| * Resolves services. | |
| * | |
| * @param string|array $value | |
| * | |
| * @return array|string|Reference | |
| */ | |
| private function resolveServices($value) | |
| { | |
| if (is_array($value)) { | |
| $value = array_map(array($this, 'resolveServices'), $value); | |
| } elseif (is_string($value) && 0 === strpos($value, '@=')) { | |
| // Not supported. | |
| //return new Expression(substr($value, 2)); | |
| throw new InvalidArgumentException(sprintf("'%s' is an Expression, but expressions are not supported.", $value)); | |
| } elseif (is_string($value) && 0 === strpos($value, '@')) { | |
| if (0 === strpos($value, '@@')) { | |
| $value = substr($value, 1); | |
| $invalidBehavior = null; | |
| } elseif (0 === strpos($value, '@?')) { | |
| $value = substr($value, 2); | |
| $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE; | |
| } else { | |
| $value = substr($value, 1); | |
| $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE; | |
| } | |
| if ('=' === substr($value, -1)) { | |
| $value = substr($value, 0, -1); | |
| $strict = false; | |
| } else { | |
| $strict = true; | |
| } | |
| if (null !== $invalidBehavior) { | |
| $value = new Reference($value, $invalidBehavior, $strict); | |
| } | |
| } | |
| return $value; | |
| } | |
| } |