17904759627

Committed 15 Sep 2025 08:47AM UTC coverage: 90.676% (-2.1%) from 92.767%

Build # 17904759627

Build Type

push

github

Committed by

NamelessCoder

Commit Message

[TASK] Set beta stability

Run Details

6924 of 7636 relevant lines covered (90.68%)

9.49 hits per line

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

90.63

/Classes/Integration/Overrides/AbstractChimeraConfigurationManager.php

<?php
declare(strict_types=1);
namespace FluidTYPO3\Flux\Integration\Overrides;

use Psr\Container\ContainerInterface;
use Psr\Http\Message\ServerRequestInterface;
use TYPO3\CMS\Core\Http\ApplicationType;
use TYPO3\CMS\Core\Http\ServerRequest;
use TYPO3\CMS\Extbase\Configuration\BackendConfigurationManager;
use TYPO3\CMS\Extbase\Configuration\ConfigurationManager;
use TYPO3\CMS\Extbase\Configuration\Exception\InvalidConfigurationTypeException;
use TYPO3\CMS\Extbase\Configuration\FrontendConfigurationManager;
use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;

abstract class AbstractChimeraConfigurationManager extends ConfigurationManager
{
    protected ContainerInterface $container;
    protected FrontendConfigurationManager $frontendConfigurationManager;
    protected BackendConfigurationManager $backendConfigurationManager;
    protected ?ApplicationType $applicationType = null;

    /** @var ServerRequest|ServerRequestInterface|null */
    protected $request = null;

    public function getConfiguration(
        string $configurationType,
        string $extensionName = null,
        string $pluginName = null
    ): array {
        $configurationManager = $this->resolveConfigurationManager();

        switch ($configurationType) {
            case self::CONFIGURATION_TYPE_SETTINGS:
                $configuration = $configurationManager->getConfiguration($extensionName, $pluginName);
                return $configuration['settings'] ?? [];
            case self::CONFIGURATION_TYPE_FRAMEWORK:
                return $configurationManager->getConfiguration($extensionName, $pluginName);
            case self::CONFIGURATION_TYPE_FULL_TYPOSCRIPT:
                return $configurationManager->getTypoScriptSetup();
            default:
                throw new InvalidConfigurationTypeException(
                    'Invalid configuration type "' . $configurationType . '"',
                    1206031879
                );
        }
    }

    public function setConfiguration(array $configuration = []): void
    {
        parent::setConfiguration($configuration);
        $this->resolveConfigurationManager()->setConfiguration($configuration);
    }

    public function setContentObject(ContentObjectRenderer $contentObject): void
    {
        parent::setContentObject($contentObject);
        $this->resolveConfigurationManager()->setContentObject($contentObject);
    }

    /**
     * @param ServerRequestInterface|ServerRequest $request
     */
    protected function updateRequest($request): void
    {
        $this->applicationType = ApplicationType::fromRequest($request);
        $this->request = $request;

        if (method_exists(ConfigurationManager::class, 'setRequest')) {
            parent::setRequest($request);
            $this->frontendConfigurationManager->setRequest($request);
            $this->backendConfigurationManager->setRequest($request);
        }
    }

    protected function refreshRequestIfNecessary(): void
    {
        /** @var ServerRequestInterface|ServerRequest|null $request */
        $request = $GLOBALS['TYPO3_REQUEST'] ?? null;
        if (($request instanceof ServerRequestInterface || $request instanceof ServerRequest)
            && $request !== $this->request
        ) {
            $this->updateRequest($request);
        }
    }

    /**
     * @return BackendConfigurationManager|FrontendConfigurationManager
     */
    private function resolveConfigurationManager()
    {
        $this->refreshRequestIfNecessary();
        if ($this->applicationType instanceof ApplicationType && $this->applicationType->isFrontend()) {
            $this->concreteConfigurationManager = $this->frontendConfigurationManager;
            return $this->frontendConfigurationManager;
        }
        $this->concreteConfigurationManager = $this->backendConfigurationManager;
        return $this->backendConfigurationManager;
    }
}

1	<?php
2	declare(strict_types=1);
3	namespace FluidTYPO3\Flux\Integration\Overrides;
4
5	use Psr\Container\ContainerInterface;
6	use Psr\Http\Message\ServerRequestInterface;
7	use TYPO3\CMS\Core\Http\ApplicationType;
8	use TYPO3\CMS\Core\Http\ServerRequest;
9	use TYPO3\CMS\Extbase\Configuration\BackendConfigurationManager;
10	use TYPO3\CMS\Extbase\Configuration\ConfigurationManager;
11	use TYPO3\CMS\Extbase\Configuration\Exception\InvalidConfigurationTypeException;
12	use TYPO3\CMS\Extbase\Configuration\FrontendConfigurationManager;
13	use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
14
15	abstract class AbstractChimeraConfigurationManager extends ConfigurationManager
16	{
17	protected ContainerInterface $container;
18	protected FrontendConfigurationManager $frontendConfigurationManager;
19	protected BackendConfigurationManager $backendConfigurationManager;
20	protected ?ApplicationType $applicationType = null;
21
22	/** @var ServerRequest\|ServerRequestInterface\|null */
23	protected $request = null;
24
25	public function getConfiguration(
26	string $configurationType,
27	string $extensionName = null,
28	string $pluginName = null
29	): array {
30	$configurationManager = $this->resolveConfigurationManager();	7✔
31
32	switch ($configurationType) {
33	case self::CONFIGURATION_TYPE_SETTINGS:	7✔
34	$configuration = $configurationManager->getConfiguration($extensionName, $pluginName);	2✔
35	return $configuration['settings'] ?? [];	2✔
36	case self::CONFIGURATION_TYPE_FRAMEWORK:	5✔
37	return $configurationManager->getConfiguration($extensionName, $pluginName);	2✔
38	case self::CONFIGURATION_TYPE_FULL_TYPOSCRIPT:	3✔
39	return $configurationManager->getTypoScriptSetup();	2✔
40	default:
41	throw new InvalidConfigurationTypeException(	1✔
42	'Invalid configuration type "' . $configurationType . '"',	1✔
43	1206031879	1✔
44	);	1✔
45	}
46	}
47
48	public function setConfiguration(array $configuration = []): void
49	{
50	parent::setConfiguration($configuration);	1✔
51	$this->resolveConfigurationManager()->setConfiguration($configuration);	1✔
52	}
53
54	public function setContentObject(ContentObjectRenderer $contentObject): void
55	{
56	parent::setContentObject($contentObject);	1✔
57	$this->resolveConfigurationManager()->setContentObject($contentObject);	1✔
58	}
59
60	/**
61	* @param ServerRequestInterface\|ServerRequest $request
62	*/
63	protected function updateRequest($request): void
64	{
65	$this->applicationType = ApplicationType::fromRequest($request);	9✔
66	$this->request = $request;	9✔
67
68	if (method_exists(ConfigurationManager::class, 'setRequest')) {	9✔
69	parent::setRequest($request);	×
70	$this->frontendConfigurationManager->setRequest($request);	×
71	$this->backendConfigurationManager->setRequest($request);	×
72	}
73	}
74
75	protected function refreshRequestIfNecessary(): void
76	{
77	/** @var ServerRequestInterface\|ServerRequest\|null $request */
78	$request = $GLOBALS['TYPO3_REQUEST'] ?? null;	9✔
79	if (($request instanceof ServerRequestInterface \|\| $request instanceof ServerRequest)	9✔
80	&& $request !== $this->request	9✔
81	) {
82	$this->updateRequest($request);	2✔
83	}
84	}
85
86	/**
87	* @return BackendConfigurationManager\|FrontendConfigurationManager
88	*/
89	private function resolveConfigurationManager()
90	{
91	$this->refreshRequestIfNecessary();	9✔
92	if ($this->applicationType instanceof ApplicationType && $this->applicationType->isFrontend()) {	9✔
93	$this->concreteConfigurationManager = $this->frontendConfigurationManager;	6✔
94	return $this->frontendConfigurationManager;	6✔
95	}
96	$this->concreteConfigurationManager = $this->backendConfigurationManager;	3✔
97	return $this->backendConfigurationManager;	3✔
98	}
99	}

FluidTYPO3 / flux / 17904759627

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