9.5/_builder_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Frontend\Tests\Functional\SiteHandling\Framework\Builder;


/*

 * 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!

 */


class ‪Builder

{

    public static function ‪create(): self

    {

        return new static();

    }


    public function ‪declareEnhancers(): array

    {

        $routePath = ‪VariableValue::create(

            '/[[routePrefix]]/[[routeParameter]]',

            ‪Variables::create(['routeParameter' => '{value}'])

        );

        $resolveValue = ‪Variable::create('resolveValue', ‪Variable::CAST_STRING);


        return [

            'Simple' => ‪EnhancerDeclaration::create('Simple')

                ->withConfiguration([

                    'type' => 'Simple',

                    'routePath' => $routePath,

                    '_arguments' => [],

                ])

                ->withGenerateParameters([

                    ‪VariableValue::create('&value=[[value]]')

                        ->withRequiredDefinedVariableNames('value'),

                ])

                ->withResolveArguments([

                    ‪VariableItem::create('inArguments', [

                        'value' => $resolveValue

                    ]),

                ]),

            'Plugin' => ‪EnhancerDeclaration::create('Plugin')

                ->withConfiguration([

                    'type' => 'Plugin',

                    'routePath' => $routePath,

                    'namespace' => 'testing',

                    '_arguments' => [],

                ])

                ->withGenerateParameters([

                    ‪VariableValue::create('&testing[value]=[[value]]')

                        ->withRequiredDefinedVariableNames('value'),

                ])

                ->withResolveArguments([

                    ‪VariableItem::create('inArguments', [

                        'testing' => [

                            'value' => $resolveValue,

                        ],

                    ]),

                ]),

            'Extbase' => ‪EnhancerDeclaration::create('Extbase')

                ->withConfiguration([

                    'type' => 'Extbase',

                    'routes' => [

                        [

                            'routePath' => $routePath,

                            '_controller' => 'Link::index',

                            '_arguments' => [],

                        ],

                    ],

                    'extension' => 'testing',

                    'plugin' => 'link',

                ])

                ->withGenerateParameters([

                    ‪VariableValue::create('&tx_testing_link[value]=[[value]]')

                        ->withRequiredDefinedVariableNames('value'),

                    '&tx_testing_link[controller]=Link&tx_testing_link[action]=index',

                ])

                ->withResolveArguments([

                    ‪VariableItem::create('inArguments', [

                        'tx_testing_link' => [

                            'value' => $resolveValue,

                        ],

                    ]),

                    'staticArguments' => [

                        'tx_testing_link' => [

                            'controller' => 'Link',

                            'action' => 'index',

                        ],

                    ],

                ])

        ];

    }


    public function ‪declarePageTypes(): array

    {

        $multipleTypesConfiguration = [

            'type' => 'PageType',

            'default' => '.html',

            'index' => 'index',

            'map' => [

                '.html' =>  0,

                'menu.json' =>  10,

                '.xml' => 20

            ],

        ];

        $singleTypeConfiguration = [

            'type' => 'PageType',

            'default' => '/',

            'index' => '/',

            'map' => [

                'menu.json' => 10,

            ],

        ];


        return [

            ‪PageTypeDeclaration::create('null ".html"')

                ->withConfiguration($multipleTypesConfiguration)

                ->withResolveArguments(['pageType' => 0])

                ->withVariables(‪Variables::create(['pathSuffix' => '.html', 'index' => 'index'])),

            ‪PageTypeDeclaration::create('0 ".html"')

                ->withConfiguration($multipleTypesConfiguration)

                ->withGenerateParameters(['&type=0'])

                ->withResolveArguments(['pageType' => 0])

                ->withVariables(‪Variables::create(['pathSuffix' => '.html', 'index' => 'index'])),

            ‪PageTypeDeclaration::create('10 "/menu.json"')

                ->withConfiguration($multipleTypesConfiguration)

                ->withGenerateParameters(['&type=10'])

                ->withResolveArguments(['pageType' => 10])

                ->withVariables(‪Variables::create(['pathSuffix' => '/menu.json', 'index' => ''])),

            ‪PageTypeDeclaration::create('20 ".xml"')

                ->withConfiguration($multipleTypesConfiguration)

                ->withGenerateParameters(['&type=20'])

                ->withResolveArguments(['pageType' => 20])

                ->withVariables(‪Variables::create(['pathSuffix' => '.xml', 'index' => 'index'])),

            ‪PageTypeDeclaration::create('null "/"')

                ->withConfiguration($singleTypeConfiguration)

                ->withResolveArguments(['pageType' => 0])

                ->withVariables(‪Variables::create(['pathSuffix' => '/', 'index' => ''])),

            ‪PageTypeDeclaration::create('0 "/"')

                ->withConfiguration($singleTypeConfiguration)

                ->withGenerateParameters(['&type=0'])

                ->withResolveArguments(['pageType' => 0])

                ->withVariables(‪Variables::create(['pathSuffix' => '/', 'index' => ''])),

        ];

    }


    public function ‪compileEnhancerConfiguration(‪TestSet $testSet): array

    {

        $enhancerConfiguration = [];

        foreach ($testSet->‪getApplicables(EnhancerDeclaration::class) as $enhancerDeclaration) {

            $enhancerConfiguration = array_replace_recursive(

                $enhancerConfiguration,

                (new ‪VariableCompiler($enhancerDeclaration->getConfiguration(), $testSet->‪getVariables()))

                    ->compile()

                    ->getResults()

            );

        }

        foreach ($testSet->‪getApplicables(AspectDeclaration::class) as $aspectDeclaration) {

            $enhancerConfiguration['aspects'] = array_replace_recursive(

                $enhancerConfiguration['aspects'] ?? [],

                (new ‪VariableCompiler($aspectDeclaration->getConfiguration(), $testSet->‪getVariables()))

                    ->compile()

                    ->getResults()

            );

        }

        return $enhancerConfiguration;

    }


    public function ‪compilePageTypeConfiguration(‪TestSet $testSet): array

    {

        $pageTypeConfiguration = [];

        foreach ($testSet->‪getApplicables(PageTypeDeclaration::class) as $pageTypeDeclaration) {

            $pageTypeConfiguration = array_replace_recursive(

                $pageTypeConfiguration,

                (new ‪VariableCompiler($pageTypeDeclaration->getConfiguration(), $testSet->‪getVariables()))

                    ->compile()

                    ->getResults()

            );

        }

        return $pageTypeConfiguration;

    }


    public function ‪compileGenerateParameters(‪TestSet $testSet): string

    {

        $generateParameters = [];

        foreach ($testSet->‪getApplicables(HasGenerateParameters::class) as $applicable) {

            $generateParameters[] = $applicable->getGenerateParameters();

        }

        $generateParameters = (new ‪VariableCompiler($generateParameters, $testSet->‪getVariables()))

            ->compile()

            ->getResults();

        return implode('', array_merge([], ...$generateParameters));

    }


    public function ‪compileUrl(‪TestSet $testSet): string

    {

        return $testSet->‪getUrl()->‪apply($testSet->‪getVariables());

    }


    public function ‪compileResolveArguments(‪TestSet $testSet): array

    {

        $resolveArguments = [];

        foreach ($testSet->‪getApplicables(HasResolveArguments::class) as $applicable) {

            $resolveArguments = array_replace_recursive(

                $resolveArguments,

                (new ‪VariableCompiler($applicable->getResolveArguments(), $testSet->‪getVariables()))

                    ->compile()

                    ->getResults()

            );

        }

        $resolveArguments['staticArguments'] = $resolveArguments['staticArguments'] ?? [];

        $resolveArguments['dynamicArguments'] = $resolveArguments['dynamicArguments'] ?? [];

        $resolveArguments['queryArguments'] = $resolveArguments['queryArguments'] ?? [];

        // generate ("assume") `routeArguments` from expected static and dynamic arguments if not declared

        $resolveArguments['routeArguments'] = $resolveArguments['routeArguments'] ?? array_replace_recursive(

            $resolveArguments['staticArguments'],

            $resolveArguments['dynamicArguments']

        );

        if (preg_match('#\?cHash=([a-z0-9]+)#i', $this->‪compileUrl($testSet), $matches)) {

            $resolveArguments['dynamicArguments']['cHash'] = $matches[1];

            $resolveArguments['queryArguments']['cHash'] = $matches[1];

        }


        return $resolveArguments;

    }

}