YamlFileLoader.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Core\Configuration\Loader;
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Symfony\Component\Yaml\Yaml;
use ‪TYPO3\CMS\Core\Configuration\Loader\Exception\YamlFileLoadingException;
use ‪TYPO3\CMS\Core\Configuration\Loader\Exception\YamlParseException;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
class ‪YamlFileLoader implements LoggerAwareInterface
{
    use LoggerAwareTrait;
 
    public const ‪PROCESS_PLACEHOLDERS = 1;
    public const ‪PROCESS_IMPORTS = 2;
 
    public function ‪load(string $fileName, int $flags = self::PROCESS_PLACEHOLDERS | self::PROCESS_IMPORTS): array
    {
        $content = $this->‪getFileContents($fileName);
        $content = Yaml::parse($content);
 
        if (!is_array($content)) {
            throw new ‪YamlParseException(
                'YAML file "' . $fileName . '" could not be parsed into valid syntax, probably empty?',
                1497332874
            );
        }
 
        if (($flags & self::PROCESS_IMPORTS) === self::PROCESS_IMPORTS) {
            $content = $this->‪processImports($content);
        }
        if (($flags & self::PROCESS_PLACEHOLDERS) === self::PROCESS_PLACEHOLDERS) {
            // Check for "%" placeholders
            $content = $this->‪processPlaceholders($content, $content);
        }
 
        return $content;
    }
 
    protected function ‪getFileContents(string $fileName): string
    {
        $streamlinedFileName = GeneralUtility::getFileAbsFileName($fileName);
        if (!$streamlinedFileName) {
            throw new ‪YamlFileLoadingException('YAML File "' . $fileName . '" could not be loaded', 1485784246);
        }
        return file_get_contents($streamlinedFileName);
    }
 
    protected function ‪getValueFromEnv(string $value): string
    {
        $matches = [];
        preg_match_all('/%env\‍([\'"]?(\w+)[\'"]?\‍)%/', $value, $matches);
        $envVars = array_combine($matches[0], $matches[1]);
        foreach ($envVars as $substring => $envVarName) {
            $envVar = getenv($envVarName);
            $value = $envVar ? str_replace($substring, $envVar, $value) : $value;
        }
        return $value;
    }
 
    protected function ‪processImports(array $content): array
    {
        if (isset($content['imports']) && is_array($content['imports'])) {
            foreach ($content['imports'] as $import) {
                try {
                    $importedContent = $this->‪load($import['resource']);
                    // override the imported content with the one from the current file
                    $content = $this->‪merge($importedContent, $content);
                } catch (‪YamlParseException | ‪YamlFileLoadingException $exception) {
                    $this->logger->error($exception->getMessage(), ['exception' => $exception]);
                }
            }
            unset($content['imports']);
        }
        return $content;
    }
 
    protected function ‪processPlaceholders(array $content, array $referenceArray): array
    {
        foreach ($content as $k => $v) {
            if ($this->‪isEnvPlaceholder($v)) {
                $content[$k] = $this->‪getValueFromEnv($v);
            } elseif ($this->‪isPlaceholder($v)) {
                $content[$k] = $this->‪getValueFromReferenceArray($v, $referenceArray);
            } elseif (is_array($v)) {
                $content[$k] = $this->‪processPlaceholders($v, $referenceArray);
            }
        }
        return $content;
    }
 
    protected function ‪getValueFromReferenceArray(string $placeholder, array $referenceArray)
    {
        $pointer = trim($placeholder, '%');
        $parts = explode('.', $pointer);
        $referenceData = $referenceArray;
        foreach ($parts as $part) {
            if (isset($referenceData[$part])) {
                $referenceData = $referenceData[$part];
            } else {
                // return unsubstituted placeholder
                return $placeholder;
            }
        }
        if ($this->‪isPlaceholder($referenceData)) {
            $referenceData = $this->‪getValueFromReferenceArray($referenceData, $referenceArray);
        }
        return $referenceData;
    }
 
    protected function ‪isPlaceholder($value): bool
    {
        return is_string($value) && strpos($value, '%') === 0 && substr($value, -1) === '%';
    }
 
    protected function ‪isEnvPlaceholder($value): bool
    {
        return is_string($value) && (strpos($value, '%env(') !== false);
    }
 
    protected function ‪merge(array $val1, array $val2): array
    {
        // Simple lists get merged / added up
        if (count(array_filter(array_keys($val1), 'is_int')) === count($val1)) {
            return array_merge($val1, $val2);
        }
        foreach ($val1 as $k => $v) {
            // The key also exists in second array, if it is a simple value
            // then $val2 will override the value, where an array is calling merge() recursively.
            if (isset($val2[$k])) {
                if (is_array($v) && isset($val2[$k])) {
                    if (is_array($val2[$k])) {
                        $val1[$k] = $this->‪merge($v, $val2[$k]);
                    } else {
                        $val1[$k] = $val2[$k];
                    }
                } else {
                    $val1[$k] = $val2[$k];
                }
                unset($val2[$k]);
            }
        }
        // If there are properties in the second array left, they are added up
        if (!empty($val2)) {
            foreach ($val2 as $k => $v) {
                $val1[$k] = $v;
            }
        }
 
        return $val1;
    }
}