27757675993

Committed 18 Jun 2026 11:55AM UTC coverage: 89.162% (-3.5%) from 92.646%

Build # 27757675993

Build Type

push

github

Committed by

NamelessCoder

Commit Message

[TASK] Address last phpstan warnings

Coverage Stats

6228 of 6985 relevant lines covered (89.16%)

40.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.43

/Classes/Integration/Configuration/SpooledConfigurationApplicator.php

<?php
namespace FluidTYPO3\Flux\Integration\Configuration;

/*
 * This file is part of the FluidTYPO3/Flux project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

use Doctrine\DBAL\Exception\TableNotFoundException;
use FluidTYPO3\Flux\Builder\ContentTypeBuilder;
use FluidTYPO3\Flux\Builder\RequestBuilder;
use FluidTYPO3\Flux\Content\ContentTypeManager;
use FluidTYPO3\Flux\Content\TypeDefinition\FluidRenderingContentTypeDefinitionInterface;
use FluidTYPO3\Flux\Core;
use FluidTYPO3\Flux\Enum\FormOption;
use FluidTYPO3\Flux\Form;
use FluidTYPO3\Flux\Provider\Provider;
use FluidTYPO3\Flux\Provider\ProviderInterface;
use FluidTYPO3\Flux\Service\CacheService;
use FluidTYPO3\Flux\Utility\ExtensionNamingUtility;
use FluidTYPO3\Flux\Utility\VersionUtility;
use Symfony\Component\Finder\Finder;
use TYPO3\CMS\Core\Core\ApplicationContext;
use TYPO3\CMS\Core\Core\Environment;
use TYPO3\CMS\Core\Exception\Page\PageNotFoundException;
use TYPO3\CMS\Core\Package\PackageManager;
use TYPO3\CMS\Core\Schema\TcaSchemaFactory;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3Fluid\Fluid\Exception;

class SpooledConfigurationApplicator
{
    private const string CACHE_ID_SORTINGS = 'flux_contentType_sortingValues';

    private ContentTypeBuilder $contentTypeBuilder;
    private ContentTypeManager $contentTypeManager;
    private RequestBuilder $requestBuilder;
    private PackageManager $packageManager;
    private CacheService $cacheService;

    public function __construct(
        ContentTypeBuilder $contentTypeBuilder,
        ContentTypeManager $contentTypeManager,
        RequestBuilder $requestBuilder,
        PackageManager $packageManager,
        CacheService $cacheService
    ) {
        $this->contentTypeBuilder = $contentTypeBuilder;
        $this->contentTypeManager = $contentTypeManager;
        $this->requestBuilder = $requestBuilder;
        $this->packageManager = $packageManager;
        $this->cacheService = $cacheService;
    }

    public function processData(): void
    {
        // Initialize the TCA needed by "template as CType" integrations
        $this->spoolQueuedContentTypeTableConfigurations(Core::getQueuedContentTypeRegistrations());

        foreach ($this->contentTypeManager->fetchContentTypes() as $contentType) {
            if (!$contentType instanceof FluidRenderingContentTypeDefinitionInterface) {
                continue;
            }
            Core::registerTemplateAsContentType(
                $contentType->getExtensionIdentity(),
                $contentType->getTemplatePathAndFilename(),
                $contentType->getContentTypeName(),
                $contentType->getProviderClassName()
            );
        }

        $this->spoolQueuedContentTypeRegistrations(Core::getQueuedContentTypeRegistrations());
        Core::clearQueuedContentTypeRegistrations();

        $scopedRequire = static function (string $filename): void {
            require $filename;
        };

        $activePackages = $this->packageManager->getActivePackages();
        foreach ($activePackages as $package) {
            try {
                $finder = Finder::create()
                    ->files()
                    ->sortByName()
                    ->depth(0)
                    ->name('*.php')
                    ->in($package->getPackagePath() . 'Configuration/TCA/Flux');
            } catch (\InvalidArgumentException $e) {
                // No such directory in this package
                continue;
            }
            foreach ($finder as $fileInfo) {
                $scopedRequire($fileInfo->getPathname());
            }
        }

        if (VersionUtility::isCoreAtLeast13()) {
            // Fix TYPO3 13+ loading order of TCA for schemaFactory, flux does its TCA stuff too late, so we rebuild
            // the tcaSchema after flux has done its work.
            $tcaSchemaFactory = GeneralUtility::makeInstance(TcaSchemaFactory::class);
            $tcaSchemaFactory->rebuild($GLOBALS['TCA']);
        }
    }

    private function spoolQueuedContentTypeTableConfigurations(array $queue): void
    {
        foreach ($queue as $queuedRegistration) {
            [$extensionName, $templatePathAndFilename, , $contentType] = $queuedRegistration;
            $contentType = $contentType ?: $this->determineContentType($extensionName, $templatePathAndFilename);
            $this->contentTypeBuilder->addBoilerplateTableConfiguration($contentType);
        }
    }

    private function determineContentType(
        string $providerExtensionName,
        string $templatePathAndFilename
    ): string {
        // Determine which plugin name and controller action to emulate with this CType, base on file name.
        $controllerExtensionName = $providerExtensionName;
        $emulatedPluginName = ucfirst(pathinfo($templatePathAndFilename, PATHINFO_FILENAME));
        $extensionSignature = str_replace('_', '', ExtensionNamingUtility::getExtensionKey($controllerExtensionName));
        $fullContentType = $extensionSignature . '_' . strtolower($emulatedPluginName);
        return $fullContentType;
    }

    protected function spoolQueuedContentTypeRegistrations(array $queue): void
    {
        $applicationContext = $this->getApplicationContext();
        $providers = [];
        foreach ($queue as $queuedRegistration) {
            [
                $providerExtensionName,
                $templateFilename,
                $providerClassName,
                $contentType,
                $pluginName,
                $controllerActionName
            ] = $queuedRegistration;
            try {
                $contentType = $contentType ?: $this->determineContentType($providerExtensionName, $templateFilename);
                $defaultControllerExtensionName = 'FluidTYPO3.Flux';

                /** @var ProviderInterface $provider */
                $provider = $this->contentTypeBuilder->configureContentTypeFromTemplateFile(
                    $providerExtensionName,
                    $templateFilename,
                    $providerClassName ?? Provider::class,
                    $contentType,
                    $defaultControllerExtensionName,
                    $controllerActionName
                );

                $provider->setPluginName($pluginName);

                Core::registerConfigurationProvider($provider);

                $providers[] = $provider;
            } catch (Exception $error) {
                if (!$applicationContext->isProduction()) {
                    throw $error;
                }
            }
        }

        $backup = $GLOBALS['TYPO3_REQUEST'] ?? null;

        $GLOBALS['TYPO3_REQUEST'] = $this->requestBuilder->getServerRequest();

        $sortingValues = $this->resolveSortingValues($providers);
        uasort(
            $providers,
            function (ProviderInterface $item1, ProviderInterface $item2) use ($sortingValues) {
                $contentType1 = $item1->getContentObjectType();
                $contentType2 = $item2->getContentObjectType();
                return ($sortingValues[$contentType1] ?? 0) <=> ($sortingValues[$contentType2] ?? 0);
            }
        );

        $providerExtensionNamesToFlush = [];

        foreach ($providers as $provider) {
            $contentType = $provider->getContentObjectType();
            $virtualRecord = ['CType' => $contentType];
            $providerExtensionName = $provider->getExtensionKey($virtualRecord);

            $providerExtensionNamesToFlush[] = $providerExtensionName;

            try {
                $this->contentTypeBuilder->registerContentType($providerExtensionName, $contentType, $provider);
            } catch (PageNotFoundException|TableNotFoundException $error) {
                // Suppressed: Flux bootstrap does not care if a page can be resolved or not.
            } catch (Exception $error) {
                if (!$applicationContext->isProduction()) {
                    $GLOBALS['TYPO3_REQUEST'] = $backup;
                    throw $error;
                }
            }
        }

        // Flush the cache entry that was generated; make sure any TypoScript overrides will take place once
        // all TypoScript is finally loaded.
        foreach (array_unique($providerExtensionNamesToFlush) as $providerExtensionName) {
            $this->cacheService->remove(
                'viewpaths_' . ExtensionNamingUtility::getExtensionKey($providerExtensionName)
            );
        }

        $GLOBALS['TYPO3_REQUEST'] = $backup;
    }

    /**
     * @param ProviderInterface[] $providers
     */
    private function resolveSortingValues(array $providers): array
    {
        /** @var array|false $fromCache */
        $fromCache = $this->cacheService->getFromCaches(self::CACHE_ID_SORTINGS);
        if ($fromCache) {
            return $fromCache;
        }

        $store = true;
        $sortingValues = [];
        foreach ($providers as $provider) {
            $contentObjectType = $provider->getContentObjectType();
            try {
                $form = $provider->getForm(['CType' => $contentObjectType]);
                $sortingValues[$contentObjectType] = $this->resolveSortingValue($form);
            } catch (\Exception $exception) {
                // A raised exception is ignored and causes sorting value to be "0", but disables storing to cache.
                $store = false;
            }
        }

        if ($store) {
            $this->cacheService->setInCaches($sortingValues, true, self::CACHE_ID_SORTINGS);
        }

        return $sortingValues;
    }

    private function resolveSortingValue(?Form $form): string
    {
        $sortingOptionValue = 0;
        if ($form instanceof Form\FormInterface) {
            if ($form->hasOption(FormOption::SORTING)) {
                $sortingOptionValue = $form->getOption(FormOption::SORTING);
            } elseif ($form->hasOption(FormOption::TEMPLATE_FILE)) {
                /** @var string $templateFilename */
                $templateFilename = $form->getOption(FormOption::TEMPLATE_FILE);
                $sortingOptionValue = basename($templateFilename);
            } else {
                $sortingOptionValue = $form->getId();
            }
        }
        return !is_scalar($sortingOptionValue) ? '0' : (string) $sortingOptionValue;
    }

    /**
     * @codeCoverageIgnore
     */
    protected function getApplicationContext(): ApplicationContext
    {
        return Environment::getContext();
    }
}

1	<?php
2	namespace FluidTYPO3\Flux\Integration\Configuration;
3
4	/*
5	* This file is part of the FluidTYPO3/Flux project under GPLv2 or later.
6	*
7	* For the full copyright and license information, please read the
8	* LICENSE.md file that was distributed with this source code.
9	*/
10
11	use Doctrine\DBAL\Exception\TableNotFoundException;
12	use FluidTYPO3\Flux\Builder\ContentTypeBuilder;
13	use FluidTYPO3\Flux\Builder\RequestBuilder;
14	use FluidTYPO3\Flux\Content\ContentTypeManager;
15	use FluidTYPO3\Flux\Content\TypeDefinition\FluidRenderingContentTypeDefinitionInterface;
16	use FluidTYPO3\Flux\Core;
17	use FluidTYPO3\Flux\Enum\FormOption;
18	use FluidTYPO3\Flux\Form;
19	use FluidTYPO3\Flux\Provider\Provider;
20	use FluidTYPO3\Flux\Provider\ProviderInterface;
21	use FluidTYPO3\Flux\Service\CacheService;
22	use FluidTYPO3\Flux\Utility\ExtensionNamingUtility;
23	use FluidTYPO3\Flux\Utility\VersionUtility;
24	use Symfony\Component\Finder\Finder;
25	use TYPO3\CMS\Core\Core\ApplicationContext;
26	use TYPO3\CMS\Core\Core\Environment;
27	use TYPO3\CMS\Core\Exception\Page\PageNotFoundException;
28	use TYPO3\CMS\Core\Package\PackageManager;
29	use TYPO3\CMS\Core\Schema\TcaSchemaFactory;
30	use TYPO3\CMS\Core\Utility\GeneralUtility;
31	use TYPO3Fluid\Fluid\Exception;
32
33	class SpooledConfigurationApplicator
34	{
35	private const string CACHE_ID_SORTINGS = 'flux_contentType_sortingValues';
36
37	private ContentTypeBuilder $contentTypeBuilder;
38	private ContentTypeManager $contentTypeManager;
39	private RequestBuilder $requestBuilder;
40	private PackageManager $packageManager;
41	private CacheService $cacheService;
42
43	public function __construct(
44	ContentTypeBuilder $contentTypeBuilder,
45	ContentTypeManager $contentTypeManager,
46	RequestBuilder $requestBuilder,
47	PackageManager $packageManager,
48	CacheService $cacheService
49	) {
50	$this->contentTypeBuilder = $contentTypeBuilder;	24✔
51	$this->contentTypeManager = $contentTypeManager;	24✔
52	$this->requestBuilder = $requestBuilder;	24✔
53	$this->packageManager = $packageManager;	24✔
54	$this->cacheService = $cacheService;	24✔
55	}
56
57	public function processData(): void
58	{
59	// Initialize the TCA needed by "template as CType" integrations
60	$this->spoolQueuedContentTypeTableConfigurations(Core::getQueuedContentTypeRegistrations());	20✔
61
62	foreach ($this->contentTypeManager->fetchContentTypes() as $contentType) {	20✔
63	if (!$contentType instanceof FluidRenderingContentTypeDefinitionInterface) {	20✔
64	continue;	×
65	}
66	Core::registerTemplateAsContentType(	20✔
67	$contentType->getExtensionIdentity(),	20✔
68	$contentType->getTemplatePathAndFilename(),	20✔
69	$contentType->getContentTypeName(),	20✔
70	$contentType->getProviderClassName()	20✔
71	);	20✔
72	}
73
74	$this->spoolQueuedContentTypeRegistrations(Core::getQueuedContentTypeRegistrations());	20✔
75	Core::clearQueuedContentTypeRegistrations();	12✔
76
77	$scopedRequire = static function (string $filename): void {	12✔
78	require $filename;	×
79	};	12✔
80
81	$activePackages = $this->packageManager->getActivePackages();	12✔
82	foreach ($activePackages as $package) {	12✔
83	try {
84	$finder = Finder::create()	×
85	->files()	×
86	->sortByName()	×
87	->depth(0)	×
88	->name('*.php')	×
89	->in($package->getPackagePath() . 'Configuration/TCA/Flux');	×
90	} catch (\InvalidArgumentException $e) {	×
91	// No such directory in this package
92	continue;	×
93	}
94	foreach ($finder as $fileInfo) {	×
95	$scopedRequire($fileInfo->getPathname());	×
96	}
97	}
98
99	if (VersionUtility::isCoreAtLeast13()) {	12✔
100	// Fix TYPO3 13+ loading order of TCA for schemaFactory, flux does its TCA stuff too late, so we rebuild
101	// the tcaSchema after flux has done its work.
102	$tcaSchemaFactory = GeneralUtility::makeInstance(TcaSchemaFactory::class);	9✔
103	$tcaSchemaFactory->rebuild($GLOBALS['TCA']);	9✔
104	}
105	}
106
107	private function spoolQueuedContentTypeTableConfigurations(array $queue): void
108	{
109	foreach ($queue as $queuedRegistration) {	24✔
110	[$extensionName, $templatePathAndFilename, , $contentType] = $queuedRegistration;	12✔
111	$contentType = $contentType ?: $this->determineContentType($extensionName, $templatePathAndFilename);	12✔
112	$this->contentTypeBuilder->addBoilerplateTableConfiguration($contentType);	12✔
113	}
114	}
115
116	private function determineContentType(
117	string $providerExtensionName,
118	string $templatePathAndFilename
119	): string {
120	// Determine which plugin name and controller action to emulate with this CType, base on file name.
121	$controllerExtensionName = $providerExtensionName;	20✔
122	$emulatedPluginName = ucfirst(pathinfo($templatePathAndFilename, PATHINFO_FILENAME));	20✔
123	$extensionSignature = str_replace('_', '', ExtensionNamingUtility::getExtensionKey($controllerExtensionName));	20✔
124	$fullContentType = $extensionSignature . '_' . strtolower($emulatedPluginName);	20✔
125	return $fullContentType;	20✔
126	}
127
128	protected function spoolQueuedContentTypeRegistrations(array $queue): void
129	{
130	$applicationContext = $this->getApplicationContext();	20✔
131	$providers = [];	20✔
132	foreach ($queue as $queuedRegistration) {	20✔
133	[	20✔
134	$providerExtensionName,	20✔
135	$templateFilename,	20✔
136	$providerClassName,	20✔
137	$contentType,	20✔
138	$pluginName,	20✔
139	$controllerActionName	20✔
140	] = $queuedRegistration;	20✔
141	try {
142	$contentType = $contentType ?: $this->determineContentType($providerExtensionName, $templateFilename);	20✔
143	$defaultControllerExtensionName = 'FluidTYPO3.Flux';	20✔
144
145	/** @var ProviderInterface $provider */
146	$provider = $this->contentTypeBuilder->configureContentTypeFromTemplateFile(	20✔
147	$providerExtensionName,	20✔
148	$templateFilename,	20✔
149	$providerClassName ?? Provider::class,	20✔
150	$contentType,	20✔
151	$defaultControllerExtensionName,	20✔
152	$controllerActionName	20✔
153	);	20✔
154
155	$provider->setPluginName($pluginName);	12✔
156
157	Core::registerConfigurationProvider($provider);	12✔
158
159	$providers[] = $provider;	12✔
160	} catch (Exception $error) {	8✔
161	if (!$applicationContext->isProduction()) {	8✔
162	throw $error;	4✔
163	}
164	}
165	}
166
167	$backup = $GLOBALS['TYPO3_REQUEST'] ?? null;	16✔
168
169	$GLOBALS['TYPO3_REQUEST'] = $this->requestBuilder->getServerRequest();	16✔
170
171	$sortingValues = $this->resolveSortingValues($providers);	16✔
172	uasort(	16✔
173	$providers,	16✔
174	function (ProviderInterface $item1, ProviderInterface $item2) use ($sortingValues) {	16✔
175	$contentType1 = $item1->getContentObjectType();	12✔
176	$contentType2 = $item2->getContentObjectType();	12✔
177	return ($sortingValues[$contentType1] ?? 0) <=> ($sortingValues[$contentType2] ?? 0);	12✔
178	}	16✔
179	);	16✔
180
181	$providerExtensionNamesToFlush = [];	16✔
182
183	foreach ($providers as $provider) {	16✔
184	$contentType = $provider->getContentObjectType();	12✔
185	$virtualRecord = ['CType' => $contentType];	12✔
186	$providerExtensionName = $provider->getExtensionKey($virtualRecord);	12✔
187
188	$providerExtensionNamesToFlush[] = $providerExtensionName;	12✔
189
190	try {
191	$this->contentTypeBuilder->registerContentType($providerExtensionName, $contentType, $provider);	12✔
192	} catch (PageNotFoundException\|TableNotFoundException $error) {	8✔
193	// Suppressed: Flux bootstrap does not care if a page can be resolved or not.
194	} catch (Exception $error) {	8✔
195	if (!$applicationContext->isProduction()) {	8✔
196	$GLOBALS['TYPO3_REQUEST'] = $backup;	4✔
197	throw $error;	4✔
198	}
199	}
200	}
201
202	// Flush the cache entry that was generated; make sure any TypoScript overrides will take place once
203	// all TypoScript is finally loaded.
204	foreach (array_unique($providerExtensionNamesToFlush) as $providerExtensionName) {	12✔
205	$this->cacheService->remove(	8✔
206	'viewpaths_' . ExtensionNamingUtility::getExtensionKey($providerExtensionName)	8✔
207	);	8✔
208	}
209
210	$GLOBALS['TYPO3_REQUEST'] = $backup;	12✔
211	}
212
213	/**
214	* @param ProviderInterface[] $providers
215	*/
216	private function resolveSortingValues(array $providers): array
217	{
218	/** @var array\|false $fromCache */
219	$fromCache = $this->cacheService->getFromCaches(self::CACHE_ID_SORTINGS);	16✔
220	if ($fromCache) {	16✔
221	return $fromCache;	×
222	}
223
224	$store = true;	16✔
225	$sortingValues = [];	16✔
226	foreach ($providers as $provider) {	16✔
227	$contentObjectType = $provider->getContentObjectType();	12✔
228	try {
229	$form = $provider->getForm(['CType' => $contentObjectType]);	12✔
230	$sortingValues[$contentObjectType] = $this->resolveSortingValue($form);	12✔
231	} catch (\Exception $exception) {	×
232	// A raised exception is ignored and causes sorting value to be "0", but disables storing to cache.
233	$store = false;	×
234	}
235	}
236
237	if ($store) {	16✔
238	$this->cacheService->setInCaches($sortingValues, true, self::CACHE_ID_SORTINGS);	16✔
239	}
240
241	return $sortingValues;	16✔
242	}
243
244	private function resolveSortingValue(?Form $form): string
245	{
246	$sortingOptionValue = 0;	12✔
247	if ($form instanceof Form\FormInterface) {	12✔
248	if ($form->hasOption(FormOption::SORTING)) {	12✔
249	$sortingOptionValue = $form->getOption(FormOption::SORTING);	12✔
250	} elseif ($form->hasOption(FormOption::TEMPLATE_FILE)) {	×
251	/** @var string $templateFilename */
252	$templateFilename = $form->getOption(FormOption::TEMPLATE_FILE);	×
253	$sortingOptionValue = basename($templateFilename);	×
254	} else {
255	$sortingOptionValue = $form->getId();	×
256	}
257	}
258	return !is_scalar($sortingOptionValue) ? '0' : (string) $sortingOptionValue;	12✔
259	}
260
261	/**
262	* @codeCoverageIgnore
263	*/
264	protected function getApplicationContext(): ApplicationContext
265	{
266	return Environment::getContext();
267	}
268	}

FluidTYPO3 / flux / 27757675993

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous