9.5/_inheritances_resolver_service_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Form\Mvc\Configuration;


/*

 * 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 ‪TYPO3\CMS\Core\Utility\ArrayUtility;

use ‪TYPO3\CMS\Core\Utility\Exception\MissingArrayPathException;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Extbase\Object\ObjectManager;

use ‪TYPO3\CMS\Form\Mvc\Configuration\Exception\CycleInheritancesException;


class ‪InheritancesResolverService

{


    const ‪INHERITANCE_OPERATOR = '__inheritances';


    protected ‪$referenceConfiguration = [];


    protected ‪$inheritanceStack = [];


    protected ‪$inheritancePathToCheck = '';


    public static function ‪create(array $configuration = []): ‪InheritancesResolverService

    {

        $inheritancesResolverService = GeneralUtility::makeInstance(ObjectManager::class)

            ->get(self::class);

        $inheritancesResolverService->‪setReferenceConfiguration($configuration);

        return $inheritancesResolverService;

    }


    public function ‪reset()

    {

        $this->referenceConfiguration = [];

        $this->inheritanceStack = [];

        $this->inheritancePathToCheck = '';

        return $this;

    }


    public function ‪setReferenceConfiguration(array ‪$referenceConfiguration)

    {

        $this->referenceConfiguration = ‪$referenceConfiguration;

        return $this;

    }


    public function ‪getResolvedConfiguration(): array

    {

        $configuration = $this->‪resolve($this->referenceConfiguration);

        $configuration = $this->‪removeInheritanceOperatorRecursive($configuration);

        return $configuration;

    }


    protected function ‪resolve(

        array $configuration,

        array $pathStack = [],

        bool $setInheritancePathToCheck = true

    ): array {

        foreach ($configuration as $key => $values) {

            //add current key to pathStack

            $pathStack[] = $key;

            $path = implode('.', $pathStack);


            //check endless loop for current path

            $this->‪throwExceptionIfCycleInheritances($path, $path);


            //overwrite service property 'inheritancePathToCheck' with current path

            if ($setInheritancePathToCheck) {

                $this->inheritancePathToCheck = $path;

            }


            //if value of subnode is an array, perform a deep search iteration step

            if (is_array($configuration[$key])) {

                if (isset($configuration[$key][self::INHERITANCE_OPERATOR])) {

                    $inheritances = $this->‪getValueByPath($this->referenceConfiguration, $path . '.' . self::INHERITANCE_OPERATOR);


                    //and replace the __inheritance operator by the respective partial

                    if (is_array($inheritances)) {

                        $inheritedConfigurations = $this->‪resolveInheritancesRecursive($inheritances);

                        $configuration[$key] = array_replace_recursive($inheritedConfigurations, $configuration[$key]);

                    }


                    //remove the inheritance operator from configuration

                    unset($configuration[$key][self::INHERITANCE_OPERATOR]);

                }


                if (!empty($configuration[$key])) {

                    // resolve subnode of YAML config

                    $configuration[$key] = $this->‪resolve($configuration[$key], $pathStack);

                }

            }

            array_pop($pathStack);

        }


        return $configuration;

    }


    protected function ‪resolveInheritancesRecursive(array $inheritances): array

    {

        ksort($inheritances);

        $inheritedConfigurations = [];

        foreach ($inheritances as $inheritancePath) {

            $this->‪throwExceptionIfCycleInheritances($inheritancePath, $inheritancePath);

            $inheritedConfiguration = $this->‪getValueByPath($this->referenceConfiguration, $inheritancePath);


            if (

                isset($inheritedConfiguration[self::INHERITANCE_OPERATOR])

                && count($inheritedConfiguration) === 1

            ) {

                if ($this->inheritancePathToCheck === $inheritancePath) {

                    throw new CycleInheritancesException(

                        $this->inheritancePathToCheck . ' has cycle inheritances',

                        1474900796

                    );

                }


                $inheritedConfiguration = $this->‪resolveInheritancesRecursive(

                    $inheritedConfiguration[self::INHERITANCE_OPERATOR]

                );

            } else {

                $pathStack = explode('.', $inheritancePath);

                $key = array_pop($pathStack);

                $newConfiguration = [

                    $key => $inheritedConfiguration

                ];

                $inheritedConfiguration = $this->‪resolve(

                    $newConfiguration,

                    $pathStack,

                    false

                );

                $inheritedConfiguration = $inheritedConfiguration[$key];

            }


            if ($inheritedConfiguration === null) {

                throw new CycleInheritancesException(

                    $inheritancePath . ' does not exist within the configuration',

                    1489260796

                );

            }


            $inheritedConfigurations = array_replace_recursive(

                $inheritedConfigurations,

                $inheritedConfiguration

            );

        }


        return $inheritedConfigurations;

    }


    protected function ‪throwExceptionIfCycleInheritances(string $path, string $pathToCheck)

    {

        $configuration = $this->‪getValueByPath($this->referenceConfiguration, $path);


        if (isset($configuration[self::INHERITANCE_OPERATOR])) {

            $inheritances = $this->‪getValueByPath($this->referenceConfiguration, $path . '.' . self::INHERITANCE_OPERATOR);


            if (is_array($inheritances)) {

                foreach ($inheritances as $inheritancePath) {

                    $configuration = $this->‪getValueByPath($this->referenceConfiguration, $inheritancePath);


                    if (isset($configuration[self::INHERITANCE_OPERATOR])) {

                        $_inheritances = $this->‪getValueByPath($this->referenceConfiguration, $inheritancePath . '.' . self::INHERITANCE_OPERATOR);


                        foreach ($_inheritances as $_inheritancePath) {

                            if (strpos($pathToCheck, $_inheritancePath) === 0) {

                                throw new CycleInheritancesException(

                                    $pathToCheck . ' has cycle inheritances',

                                    1474900797

                                );

                            }

                        }

                    }


                    if (

                        isset($this->inheritanceStack[$pathToCheck])

                        && is_array($this->inheritanceStack[$pathToCheck])

                        && in_array($inheritancePath, $this->inheritanceStack[$pathToCheck])

                    ) {

                        $this->inheritanceStack[$pathToCheck][] = $inheritancePath;

                        throw new CycleInheritancesException(

                            $pathToCheck . ' has cycle inheritances',

                            1474900799

                        );

                    }

                    $this->inheritanceStack[$pathToCheck][] = $inheritancePath;

                    $this->‪throwExceptionIfCycleInheritances($inheritancePath, $pathToCheck);

                }

                $this->inheritanceStack[$pathToCheck] = null;

            }

        }

    }


    protected function ‪removeInheritanceOperatorRecursive(array $array): array

    {

        $result = $array;

        foreach ($result as $key => $value) {

            if ($key === self::INHERITANCE_OPERATOR) {

                unset($result[$key]);

                continue;

            }


            if (is_array($value)) {

                $result[$key] = $this->‪removeInheritanceOperatorRecursive($value);

            }

        }

        return $result;

    }


    protected function ‪getValueByPath(array $config, string $path, string $delimiter = '.')

    {

        try {

            return ‪ArrayUtility::getValueByPath($config, $path, $delimiter);

        } catch (MissingArrayPathException $exception) {

            return null;

        }

    }

}