TypoScriptService::injectEnvironmentService() - Code Metrics - Inspection of "[TASK] Remove dependency injection from `Core`" - romm/formz - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — cleanup-service ( 73e309...ffbb72 )

by Romain

created 2017-01-19 15:51 UTC

TypoScriptService::injectEnvironmentService() A

↳ Parent: TypoScriptService

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1

<?php
/*
 * 2017 Romain CANON <[email protected]>
 *
 * This file is part of the TYPO3 Formz project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace Romm\Formz\Service;

use Romm\Formz\Core\Core;
use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Extbase\Configuration\ConfigurationManager;
use TYPO3\CMS\Extbase\Service\EnvironmentService;
use TYPO3\CMS\Extbase\Service\TypoScriptService as ExtbaseTypoScriptService;

/**
 * Handles the TypoScript configuration of the extension.
 */
class TypoScriptService implements SingletonInterface
{
    const EXTENSION_CONFIGURATION_PATH = 'config.tx_formz';

    /**
     * @var EnvironmentService
     */
    protected $environmentService;

    /**
     * @var ExtbaseTypoScriptService
     */
    protected $typoScriptService;

    /**
     * Storage for the pages configuration.
     *
     * @var array
     */
    protected $configuration = [];

    /**
     * Returns the TypoScript configuration at the given path (starting from
     * Formz configuration root).
     *
     * @param string $path
     * @return mixed
     */
    public function getExtensionConfigurationFromPath($path)
    {
        $extensionConfiguration = $this->getExtensionConfiguration();

        return (ArrayUtility::isValidPath($extensionConfiguration, $path, '.'))
            ? ArrayUtility::getValueByPath($extensionConfiguration, $path, '.')
            : null;
    }

    /**
     * Returns the TypoScript configuration for the given form class name.
     *
     * @param string $formClassName
     * @return array
     */
    public function getFormConfiguration($formClassName)
    {
        $formzConfiguration = $this->getExtensionConfiguration();

        return (isset($formzConfiguration['forms'][$formClassName]))
            ? $formzConfiguration['forms'][$formClassName]
            : [];
    }

    /**
     * Returns the full Formz TypoScript configuration, but without the `forms`
     * key.
     *
     * @return array
     */
    public function getFormzConfiguration()
    {
        $configuration = $this->getExtensionConfiguration();
        unset($configuration['forms']);

        return $configuration;
    }

    /**
     * This function will fetch the extension TypoScript configuration, and
     * store it in cache for further usage.
     *
     * The configuration array is not stored in cache if the configuration
     * property `settings.typoScriptIncluded` is not found.
     *
     * @return array
     */
    protected function getExtensionConfiguration()
    {
        $cacheInstance = Core::get()->getCacheInstance();
        $hash = $this->getContextHash();

        if ($cacheInstance->has($hash)) {
            $result = $cacheInstance->get($hash);
        } else {
            $result = $this->getFullConfiguration();
            $result = (ArrayUtility::isValidPath($result, self::EXTENSION_CONFIGURATION_PATH, '.'))
                ? ArrayUtility::getValueByPath($result, self::EXTENSION_CONFIGURATION_PATH, '.')
                : [];

            if (ArrayUtility::isValidPath($result, 'settings.typoScriptIncluded', '.')) {
                $cacheInstance->set($hash, $result);
            }
        }

        return $result;
    }

    /**
     * Returns the full TypoScript configuration, based on the context of the
     * current request.
     *
     * @return array
     */
    protected function getFullConfiguration()
    {
        $contextHash = $this->getContextHash();

        if (false === array_key_exists($contextHash, $this->configuration)) {
            if ($this->environmentService->isEnvironmentInFrontendMode()) {
                $typoScriptArray = $this->getFrontendTypoScriptConfiguration();
            } else {
                $typoScriptArray = $this->getBackendTypoScriptConfiguration();
            }

            $this->configuration[$contextHash] = $this->typoScriptService->convertTypoScriptArrayToPlainArray($typoScriptArray);
        }

        return $this->configuration[$contextHash];
    }

    /**
     * @return array
     */
    protected function getFrontendTypoScriptConfiguration()
    {
        return Core::get()->getPageController()->tmpl->setup;
    }

    /**
     * @return array
     */
    protected function getBackendTypoScriptConfiguration()
    {
        /** @var ConfigurationManager $configurationManager */
        $configurationManager = Core::instantiate(ConfigurationManager::class);

        return $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_FULL_TYPOSCRIPT);
    }

    /**
     * Returns a unique hash for the context of the current request, depending
     * on whether the request comes from frontend or backend.
     *
     * @return string
     */
    protected function getContextHash()
    {
        return 'ts-conf-' . Core::get()->getContextHash();
    }

    /**
     * @param EnvironmentService $environmentService
     */
    public function injectEnvironmentService(EnvironmentService $environmentService)
    {
        $this->environmentService = $environmentService;
    }

    /**
     * @param ExtbaseTypoScriptService $typoScriptService
     */
    public function injectTypoScriptService(ExtbaseTypoScriptService $typoScriptService)
    {
        $this->typoScriptService = $typoScriptService;
    }
}


1			<?php
2			/*
3			* 2017 Romain CANON <[email protected]>
4			*
5			* This file is part of the TYPO3 Formz project.
6			* It is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU General Public License, either
8			* version 3 of the License, or any later version.
9			*
10			* For the full copyright and license information, see:
11			* http://www.gnu.org/licenses/gpl-3.0.html
12			*/
13
14			namespace Romm\Formz\Service;
15
16			use Romm\Formz\Core\Core;
17			use TYPO3\CMS\Core\SingletonInterface;
18			use TYPO3\CMS\Core\Utility\ArrayUtility;
19			use TYPO3\CMS\Extbase\Configuration\ConfigurationManager;
20			use TYPO3\CMS\Extbase\Service\EnvironmentService;
21			use TYPO3\CMS\Extbase\Service\TypoScriptService as ExtbaseTypoScriptService;
22
23			/**
24			* Handles the TypoScript configuration of the extension.
25			*/
26			class TypoScriptService implements SingletonInterface
27			{
28			const EXTENSION_CONFIGURATION_PATH = 'config.tx_formz';
29
30			/**
31			* @var EnvironmentService
32			*/
33			protected $environmentService;
34
35			/**
36			* @var ExtbaseTypoScriptService
37			*/
38			protected $typoScriptService;
39
40			/**
41			* Storage for the pages configuration.
42			*
43			* @var array
44			*/
45			protected $configuration = [];
46
47			/**
48			* Returns the TypoScript configuration at the given path (starting from
49			* Formz configuration root).
50			*
51			* @param string $path
52			* @return mixed
53			*/
54			public function getExtensionConfigurationFromPath($path)
55			{
56			$extensionConfiguration = $this->getExtensionConfiguration();
57
58			return (ArrayUtility::isValidPath($extensionConfiguration, $path, '.'))
59			? ArrayUtility::getValueByPath($extensionConfiguration, $path, '.')
60			: null;
61			}
62
63			/**
64			* Returns the TypoScript configuration for the given form class name.
65			*
66			* @param string $formClassName
67			* @return array
68			*/
69			public function getFormConfiguration($formClassName)
70			{
71			$formzConfiguration = $this->getExtensionConfiguration();
72
73			return (isset($formzConfiguration['forms'][$formClassName]))
74			? $formzConfiguration['forms'][$formClassName]
75			: [];
76			}
77
78			/**
79			* Returns the full Formz TypoScript configuration, but without the `forms`
80			* key.
81			*
82			* @return array
83			*/
84			public function getFormzConfiguration()
85			{
86			$configuration = $this->getExtensionConfiguration();
87			unset($configuration['forms']);
88
89			return $configuration;
90			}
91
92			/**
93			* This function will fetch the extension TypoScript configuration, and
94			* store it in cache for further usage.
95			*
96			* The configuration array is not stored in cache if the configuration
97			* property `settings.typoScriptIncluded` is not found.
98			*
99			* @return array
100			*/
101			protected function getExtensionConfiguration()
102			{
103			$cacheInstance = Core::get()->getCacheInstance();
104			$hash = $this->getContextHash();
105
106			if ($cacheInstance->has($hash)) {
107			$result = $cacheInstance->get($hash);
108			} else {
109			$result = $this->getFullConfiguration();
110			$result = (ArrayUtility::isValidPath($result, self::EXTENSION_CONFIGURATION_PATH, '.'))
111			? ArrayUtility::getValueByPath($result, self::EXTENSION_CONFIGURATION_PATH, '.')
112			: [];
113
114			if (ArrayUtility::isValidPath($result, 'settings.typoScriptIncluded', '.')) {
115			$cacheInstance->set($hash, $result);
116			}
117			}
118
119			return $result;
120			}
121
122			/**
123			* Returns the full TypoScript configuration, based on the context of the
124			* current request.
125			*
126			* @return array
127			*/
128			protected function getFullConfiguration()
129			{
130			$contextHash = $this->getContextHash();
131
132			if (false === array_key_exists($contextHash, $this->configuration)) {
133			if ($this->environmentService->isEnvironmentInFrontendMode()) {
134			$typoScriptArray = $this->getFrontendTypoScriptConfiguration();
135			} else {
136			$typoScriptArray = $this->getBackendTypoScriptConfiguration();
137			}
138
139			$this->configuration[$contextHash] = $this->typoScriptService->convertTypoScriptArrayToPlainArray($typoScriptArray);
140			}
141
142			return $this->configuration[$contextHash];
143			}
144
145			/**
146			* @return array
147			*/
148			protected function getFrontendTypoScriptConfiguration()
149			{
150			return Core::get()->getPageController()->tmpl->setup;
151			}
152
153			/**
154			* @return array
155			*/
156			protected function getBackendTypoScriptConfiguration()
157			{
158			/** @var ConfigurationManager $configurationManager */
159			$configurationManager = Core::instantiate(ConfigurationManager::class);
160
161			return $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_FULL_TYPOSCRIPT);
162			}
163
164			/**
165			* Returns a unique hash for the context of the current request, depending
166			* on whether the request comes from frontend or backend.
167			*
168			* @return string
169			*/
170			protected function getContextHash()
171			{
172			return 'ts-conf-' . Core::get()->getContextHash();
173			}
174
175			/**
176			* @param EnvironmentService $environmentService
177			*/
178			public function injectEnvironmentService(EnvironmentService $environmentService)
179			{
180			$this->environmentService = $environmentService;
181			}
182
183			/**
184			* @param ExtbaseTypoScriptService $typoScriptService
185			*/
186			public function injectTypoScriptService(ExtbaseTypoScriptService $typoScriptService)
187			{
188			$this->typoScriptService = $typoScriptService;
189			}
190			}
191

romm / formz

Push — cleanup-service ( 73e309...ffbb72 )

TypoScriptService::injectEnvironmentService() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like