YamlFileLoader.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Core\Configuration\Loader;
 
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;
use ‪TYPO3\CMS\Core\Configuration\Features;
use ‪TYPO3\CMS\Core\Configuration\Loader\Exception\YamlFileLoadingException;
use ‪TYPO3\CMS\Core\Configuration\Loader\Exception\YamlParseException;
use ‪TYPO3\CMS\Core\Configuration\Processor\PlaceholderProcessorList;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
 
class ‪YamlFileLoader implements LoggerAwareInterface
{
    use LoggerAwareTrait;
 
    public const ‪PATTERN_PARTS = '%[^(%]+?\‍([\'"]?([^(]*?)[\'"]?\‍)%|%([^%()]*?)%';
    public const ‪PROCESS_PLACEHOLDERS = 1;
    public const ‪PROCESS_IMPORTS = 2;
 
    private ‪$flags;
 
    public function ‪load(string $fileName, int ‪$flags = self::PROCESS_PLACEHOLDERS | self::PROCESS_IMPORTS): array
    {
        $this->flags = ‪$flags;
        return $this->‪loadAndParse($fileName, null);
    }
 
    protected function ‪loadAndParse(string $fileName, ?string $currentFileName): array
    {
        $sanitizedFileName = $this->‪getStreamlinedFileName($fileName, $currentFileName);
        $content = $this->‪getFileContents($sanitizedFileName);
        $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 ($this->‪hasFlag(self::PROCESS_IMPORTS)) {
            $content = $this->‪processImports($content, $sanitizedFileName);
        }
        if ($this->‪hasFlag(self::PROCESS_PLACEHOLDERS)) {
            // Check for "%" placeholders
            $content = $this->‪processPlaceholders($content, $content);
        }
        return $content;
    }
 
    protected function ‪getFileContents(string $fileName): string
    {
        return file_get_contents($fileName);
    }
 
    protected function ‪getStreamlinedFileName(string $fileName, ?string $currentFileName): string
    {
        if (!empty($currentFileName)) {
            if (strpos($fileName, 'EXT:') === 0 || GeneralUtility::isAbsPath($fileName)) {
                $streamlinedFileName = GeneralUtility::getFileAbsFileName($fileName);
            } else {
                // Now this path is considered to be relative the current file name
                $streamlinedFileName = ‪PathUtility::getAbsolutePathOfRelativeReferencedFileOrPath(
                    $currentFileName,
                    $fileName
                );
                if (!GeneralUtility::isAllowedAbsPath($streamlinedFileName)) {
                    throw new YamlFileLoadingException(
                        'Referencing a file which is outside of TYPO3s main folder',
                        1560319866
                    );
                }
            }
        } else {
            $streamlinedFileName = GeneralUtility::getFileAbsFileName($fileName);
        }
        if (!$streamlinedFileName) {
            throw new YamlFileLoadingException('YAML File "' . $fileName . '" could not be loaded', 1485784246);
        }
        return $streamlinedFileName;
    }
 
    protected function ‪processImports(array $content, ?string $fileName): array
    {
        if (isset($content['imports']) && is_array($content['imports'])) {
            if (GeneralUtility::makeInstance(Features::class)->isFeatureEnabled('yamlImportsFollowDeclarationOrder')) {
                $content['imports'] = array_reverse($content['imports']);
            }
            foreach ($content['imports'] as $import) {
                try {
                    $import = $this->‪processPlaceholders($import, $import);
                    $importedContent = $this->‪loadAndParse($import['resource'], $fileName);
                    // override the imported content with the one from the current file
                    $content = ‪ArrayUtility::replaceAndAppendScalarValuesRecursive($importedContent, $content);
                } catch (ParseException|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 (is_array($v)) {
                $content[$k] = $this->‪processPlaceholders($v, $referenceArray);
            } elseif ($this->‪containsPlaceholder($v)) {
                $content[$k] = $this->‪processPlaceholderLine($v, $referenceArray);
            }
        }
        return $content;
    }
 
    protected function ‪processPlaceholderLine(string $line, array $referenceArray)
    {
        $parts = $this->‪getParts($line);
        foreach ($parts as $partKey => $part) {
            $result = $this->‪processSinglePlaceholder($partKey, $part, $referenceArray);
            // Replace whole content if placeholder is the only thing in this line
            if ($line === $partKey) {
                $line = $result;
            } elseif (is_string($result) || is_numeric($result)) {
                $line = str_replace($partKey, $result, $line);
            } else {
                throw new \UnexpectedValueException(
                    'Placeholder can not be substituted if result is not string or numeric',
                    1581502783
                );
            }
            if ($result !== $partKey && $this->‪containsPlaceholder($line)) {
                $line = $this->‪processPlaceholderLine($line, $referenceArray);
            }
        }
        return $line;
    }
 
    protected function ‪processSinglePlaceholder(string $placeholder, string $value, array $referenceArray)
    {
        $processorList = GeneralUtility::makeInstance(
            PlaceholderProcessorList::class,
            ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['yamlLoader']['placeholderProcessors']
        );
        foreach ($processorList->compile() as $processor) {
            if ($processor->canProcess($placeholder, $referenceArray)) {
                try {
                    $result = $processor->process($value, $referenceArray);
                } catch (\UnexpectedValueException $e) {
                    $result = $placeholder;
                }
                if (is_array($result)) {
                    $result = $this->‪processPlaceholders($result, $referenceArray);
                }
                break;
            }
        }
        return $result ?? $placeholder;
    }
 
    protected function ‪getParts(string $placeholders): array
    {
        // find occurrences of placeholders like %some()% and %array.access%.
        // Only find the innermost ones, so we can nest them.
        preg_match_all(
            '/' . self::PATTERN_PARTS . '/',
            $placeholders,
            $parts,
            PREG_UNMATCHED_AS_NULL
        );
        $matches = array_filter(
            array_merge($parts[1], $parts[2])
        );
        return array_combine($parts[0], $matches);
    }
 
    protected function ‪containsPlaceholder($value): bool
    {
        return is_string($value) && substr_count($value, '%') >= 2;
    }
 
    protected function ‪hasFlag(int $flag): bool
    {
        return ($this->flags & $flag) === $flag;
    }
}