YamlDirectoryDiscovery.php

<?php

namespace Drupal\Component\Discovery;

use Drupal\Component\FileSystem\RegexDirectoryIterator;
use Drupal\Component\Serialization\Exception\InvalidDataTypeException;
use Drupal\Component\Serialization\Yaml;
use Drupal\Component\FileCache\FileCacheFactory;

/**
 * Discovers multiple YAML files in a set of directories.
 */
class YamlDirectoryDiscovery implements DiscoverableInterface {

  /**
   * Defines the key in the discovered data where the file path is stored.
   */
  const FILE_KEY = '_discovered_file_path';

  /**
   * An array of directories to scan, keyed by the provider.
   *
   * The value can either be a string or an array of strings. The string values
   * should be the path of a directory to scan.
   *
   * @var array
   */
  protected $directories = [];

  /**
   * The suffix for the file cache key.
   *
   * @var string
   */
  protected $fileCacheKeySuffix;

  /**
   * The key contained in the discovered data that identifies it.
   *
   * @var string
   */
  protected $idKey;

  /**
   * Constructs a YamlDirectoryDiscovery object.
   *
   * @param array $directories
   *   An array of directories to scan, keyed by the provider. The value can
   *   either be a string or an array of strings. The string values should be
   *   the path of a directory to scan.
   * @param string $file_cache_key_suffix
   *   The file cache key suffix. This should be unique for each type of
   *   discovery.
   * @param string $key
   *   (optional) The key contained in the discovered data that identifies it.
   *   Defaults to 'id'.
   */
  public function __construct(array $directories, $file_cache_key_suffix, $key = 'id') {
    $this->directories = $directories;
    $this->fileCacheKeySuffix = $file_cache_key_suffix;
    $this->idKey = $key;
  }

  /**
   * {@inheritdoc}
   */
  public function findAll() {
    $all = [];
    $files = $this
      ->findFiles();
    $file_cache = FileCacheFactory::get('yaml_discovery:' . $this->fileCacheKeySuffix);

    // Try to load from the file cache first.
    foreach ($file_cache
      ->getMultiple(array_keys($files)) as $file => $data) {
      $all[$files[$file]][$this
        ->getIdentifier($file, $data)] = $data;
      unset($files[$file]);
    }

    // If there are files left that were not returned from the cache, load and
    // parse them now. This list was flipped above and is keyed by filename.
    if ($files) {
      foreach ($files as $file => $provider) {

        // If a file is empty or its contents are commented out, return an empty
        // array instead of NULL for type consistency.
        try {
          $data = Yaml::decode(file_get_contents($file)) ?: [];
        } catch (InvalidDataTypeException $e) {
          throw new DiscoveryException("The {$file} contains invalid YAML", 0, $e);
        }
        $data[static::FILE_KEY] = $file;
        $all[$provider][$this
          ->getIdentifier($file, $data)] = $data;
        $file_cache
          ->set($file, $data);
      }
    }
    return $all;
  }

  /**
   * Gets the identifier from the data.
   *
   * @param string $file
   *   The filename.
   * @param array $data
   *   The data from the YAML file.
   *
   * @return string
   *   The identifier from the data.
   */
  protected function getIdentifier($file, array $data) {
    if (!isset($data[$this->idKey])) {
      throw new DiscoveryException("The {$file} contains no data in the identifier key '{$this->idKey}'");
    }
    return $data[$this->idKey];
  }

  /**
   * Returns an array of providers keyed by file path.
   *
   * @return array
   *   An array of providers keyed by file path.
   */
  protected function findFiles() {
    $file_list = [];
    foreach ($this->directories as $provider => $directories) {
      $directories = (array) $directories;
      foreach ($directories as $directory) {
        if (is_dir($directory)) {

          /** @var \SplFileInfo $fileInfo */
          foreach ($this
            ->getDirectoryIterator($directory) as $fileInfo) {
            $file_list[$fileInfo
              ->getPathname()] = $provider;
          }
        }
      }
    }
    return $file_list;
  }

  /**
   * Gets an iterator to loop over the files in the provided directory.
   *
   * This method exists so that it is easy to replace this functionality in a
   * class that extends this one. For example, it could be used to make the scan
   * recursive.
   *
   * @param string $directory
   *   The directory to scan.
   *
   * @return \Traversable
   *   An \Traversable object or array where the values are \SplFileInfo
   *   objects.
   */
  protected function getDirectoryIterator($directory) {
    return new RegexDirectoryIterator($directory, '/\\.yml$/i');
  }

}