class YamlFileLoader in Zircon Profile 8.0

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.

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.

Hierarchy

• class \Drupal\Core\DependencyInjection\YamlFileLoader

See also

\Symfony\Component\DependencyInjection\Loader\YamlFileLoader

https://github.com/symfony/symfony/pull/10920

1 file declares its use of YamlFileLoader

DrupalKernel.php in core/lib/Drupal/Core/DrupalKernel.php

Contains \Drupal\Core\DrupalKernel.

1 string reference to 'YamlFileLoader'

TranslatorTest::getTransFileTests in vendor/symfony/translation/Tests/TranslatorTest.php

File

core/lib/Drupal/Core/DependencyInjection/YamlFileLoader.php, line 34

Contains \Drupal\Core\DependencyInjection\YamlFileLoader.

Namespace

Drupal\Core\DependencyInjection

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;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
YamlFileLoader::$container	protected	property
YamlFileLoader::$fileCache	protected	property	File cache object.
YamlFileLoader::load	public	function	Loads a Yaml file.
YamlFileLoader::loadFile	protected	function	Loads a YAML file.
YamlFileLoader::parseDefinition	private	function	Parses a definition.
YamlFileLoader::parseDefinitions	private	function	Parses definitions
YamlFileLoader::resolveServices	private	function	Resolves services.
YamlFileLoader::validate	private	function	Validates a YAML file.
YamlFileLoader::__construct	public	function