AssetHandlerConnectorManager::getJavaScriptAssetHandlerConnector() - Code Metrics - romm/formz - Measure and Improve Code Quality continuously with Scrutinizer

getJavaScriptAssetHandlerConnector() A
last analyzed 2018-11-19 14:36 UTC

↳ Parent: AssetHandlerConnectorManager

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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\AssetHandler\Connector;

use Romm\Formz\AssetHandler\AssetHandlerFactory;
use Romm\Formz\Core\Core;
use Romm\Formz\Exceptions\FileCreationFailedException;
use Romm\Formz\Service\CacheService;
use TYPO3\CMS\Core\Page\PageRenderer;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/**
 * This manager is used to create instances of connectors, which will be used to
 * gather every asset used for a form, mainly JavaScript and CSS code.
 */
class AssetHandlerConnectorManager
{
    /**
     * @var AssetHandlerConnectorManager[]
     */
    private static $instances = [];

    /**
     * @var PageRenderer
     */
    private $pageRenderer;

    /**
     * @var AssetHandlerFactory
     */
    private $assetHandlerFactory;

    /**
     * @var JavaScriptAssetHandlerConnector
     */
    private $javaScriptAssetHandlerConnector;

    /**
     * @var CssAssetHandlerConnector
     */
    private $cssAssetHandlerConnector;

    /**
     * @var AssetHandlerConnectorStates
     */
    private $assetHandlerConnectorStates;

    /**
     * @param PageRenderer        $pageRenderer
     * @param AssetHandlerFactory $assetHandlerFactory
     */
    public function __construct(PageRenderer $pageRenderer, AssetHandlerFactory $assetHandlerFactory)
    {
        $this->pageRenderer = $pageRenderer;
        $this->assetHandlerFactory = $assetHandlerFactory;
        $this->cssAssetHandlerConnector = Core::instantiate(CssAssetHandlerConnector::class, $this);
        $this->javaScriptAssetHandlerConnector = Core::instantiate(JavaScriptAssetHandlerConnector::class, $this);
    }

    /**
     * @param PageRenderer        $pageRenderer
     * @param AssetHandlerFactory $assetHandlerFactory
     * @return AssetHandlerConnectorManager
     */
    public static function get(PageRenderer $pageRenderer, AssetHandlerFactory $assetHandlerFactory)
    {
        $hash = spl_object_hash($pageRenderer) . spl_object_hash($assetHandlerFactory);

        if (false === isset(self::$instances[$hash])) {
            self::$instances[$hash] = Core::instantiate(self::class, $pageRenderer, $assetHandlerFactory);
        }

        return self::$instances[$hash];
    }

    /**
     * Will take care of including internal FormZ JavaScript and CSS files. They
     * will be included only once, even if the view helper is used several times
     * in the same page.
     *
     * @return $this
     */
    public function includeDefaultAssets()
    {
        if (false === $this->assetHandlerConnectorStates->defaultAssetsWereIncluded()) {
            $this->assetHandlerConnectorStates->markDefaultAssetsAsIncluded();

            $this->getJavaScriptAssetHandlerConnector()->includeDefaultJavaScriptFiles();
            $this->getCssAssetHandlerConnector()->includeDefaultCssFiles();
        }

        return $this;
    }

    /**
     * Returns a file name based on the form object class name.
     *
     * @param string $prefix
     * @return string
     */
    public function getFormzGeneratedFilePath($prefix = '')
    {
        $formObject = $this->assetHandlerFactory->getFormObject();
        $formIdentifier = CacheService::get()->getFormCacheIdentifier($formObject->getClassName(), $formObject->getName());
        $prefix = (false === empty($prefix))
            ? $prefix . '-'
            : '';

        $identifier = substr(
            'fz-' . $prefix . $formIdentifier,
            0,
            22
        );
        $identifier .= '-' . md5($formObject->getHash() . $formObject->getName());

        return CacheService::GENERATED_FILES_PATH . $identifier;
    }

    /**
     * This function will check if the file at the given path exists. If it does
     * not, the callback is called to get the content of the file, which is put
     * in the created file.
     *
     * A boolean is returned: if the file did not exist, and it was created
     * without error, `true` is returned. Otherwise, `false` is returned.
     *
     * @param string   $relativePath
     * @param callable $callback
     * @return bool
     * @throws FileCreationFailedException
     */
    public function createFileInTemporaryDirectory($relativePath, callable $callback)
    {
        $result = false;
        $absolutePath = GeneralUtility::getFileAbsFileName($relativePath);

        if (false === $this->fileExists($absolutePath)) {
            $content = call_user_func($callback);

            $result = $this->writeTemporaryFile($absolutePath, $content);

            if (null !== $result) {
                throw FileCreationFailedException::fileCreationFailed($absolutePath, $result);
            }
        }

        return $result;
    }

    /**
     * This function is mocked in unit tests.
     *
     * @param string $absolutePath
     * @return bool
     */
    protected function fileExists($absolutePath)
    {
        return file_exists($absolutePath)
            && 0 !== filemtime($absolutePath);
    }

    /**
     * This function is mocked in unit tests.
     *
     * @param string $absolutePath
     * @param string $content
     * @return bool
     */
    protected function writeTemporaryFile($absolutePath, $content)
    {
        return GeneralUtility::writeFileToTypo3tempDir($absolutePath, $content);
    }

    /**
     * @return PageRenderer
     */
    public function getPageRenderer()
    {
        return $this->pageRenderer;
    }

    /**
     * @return AssetHandlerFactory
     */
    public function getAssetHandlerFactory()
    {
        return $this->assetHandlerFactory;
    }

    /**
     * @return AssetHandlerConnectorStates
     */
    public function getAssetHandlerConnectorStates()
    {
        return $this->assetHandlerConnectorStates;
    }

    /**
     * @return JavaScriptAssetHandlerConnector
     */
    public function getJavaScriptAssetHandlerConnector()
    {
        return $this->javaScriptAssetHandlerConnector;
    }

    /**
     * @return CssAssetHandlerConnector
     */
    public function getCssAssetHandlerConnector()
    {
        return $this->cssAssetHandlerConnector;
    }

    /**
     * @param AssetHandlerConnectorStates $assetHandlerConnectorStates
     */
    public function injectAssetHandlerConnectorStates(AssetHandlerConnectorStates $assetHandlerConnectorStates)
    {
        $this->assetHandlerConnectorStates = $assetHandlerConnectorStates;
    }
}


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\AssetHandler\Connector;
15
16			use Romm\Formz\AssetHandler\AssetHandlerFactory;
17			use Romm\Formz\Core\Core;
18			use Romm\Formz\Exceptions\FileCreationFailedException;
19			use Romm\Formz\Service\CacheService;
20			use TYPO3\CMS\Core\Page\PageRenderer;
21			use TYPO3\CMS\Core\Utility\GeneralUtility;
22
23			/**
24			* This manager is used to create instances of connectors, which will be used to
25			* gather every asset used for a form, mainly JavaScript and CSS code.
26			*/
27			class AssetHandlerConnectorManager
28			{
29			/**
30			* @var AssetHandlerConnectorManager[]
31			*/
32			private static $instances = [];
33
34			/**
35			* @var PageRenderer
36			*/
37			private $pageRenderer;
38
39			/**
40			* @var AssetHandlerFactory
41			*/
42			private $assetHandlerFactory;
43
44			/**
45			* @var JavaScriptAssetHandlerConnector
46			*/
47			private $javaScriptAssetHandlerConnector;
48
49			/**
50			* @var CssAssetHandlerConnector
51			*/
52			private $cssAssetHandlerConnector;
53
54			/**
55			* @var AssetHandlerConnectorStates
56			*/
57			private $assetHandlerConnectorStates;
58
59			/**
60			* @param PageRenderer $pageRenderer
61			* @param AssetHandlerFactory $assetHandlerFactory
62			*/
63			public function __construct(PageRenderer $pageRenderer, AssetHandlerFactory $assetHandlerFactory)
64			{
65			$this->pageRenderer = $pageRenderer;
66			$this->assetHandlerFactory = $assetHandlerFactory;
67			$this->cssAssetHandlerConnector = Core::instantiate(CssAssetHandlerConnector::class, $this);
68			$this->javaScriptAssetHandlerConnector = Core::instantiate(JavaScriptAssetHandlerConnector::class, $this);
69			}
70
71			/**
72			* @param PageRenderer $pageRenderer
73			* @param AssetHandlerFactory $assetHandlerFactory
74			* @return AssetHandlerConnectorManager
75			*/
76			public static function get(PageRenderer $pageRenderer, AssetHandlerFactory $assetHandlerFactory)
77			{
78			$hash = spl_object_hash($pageRenderer) . spl_object_hash($assetHandlerFactory);
79
80			if (false === isset(self::$instances[$hash])) {
81			self::$instances[$hash] = Core::instantiate(self::class, $pageRenderer, $assetHandlerFactory);
82			}
83
84			return self::$instances[$hash];
85			}
86
87			/**
88			* Will take care of including internal FormZ JavaScript and CSS files. They
89			* will be included only once, even if the view helper is used several times
90			* in the same page.
91			*
92			* @return $this
93			*/
94			public function includeDefaultAssets()
95			{
96			if (false === $this->assetHandlerConnectorStates->defaultAssetsWereIncluded()) {
97			$this->assetHandlerConnectorStates->markDefaultAssetsAsIncluded();
98
99			$this->getJavaScriptAssetHandlerConnector()->includeDefaultJavaScriptFiles();
100			$this->getCssAssetHandlerConnector()->includeDefaultCssFiles();
101			}
102
103			return $this;
104			}
105
106			/**
107			* Returns a file name based on the form object class name.
108			*
109			* @param string $prefix
110			* @return string
111			*/
112			public function getFormzGeneratedFilePath($prefix = '')
113			{
114			$formObject = $this->assetHandlerFactory->getFormObject();
115			$formIdentifier = CacheService::get()->getFormCacheIdentifier($formObject->getClassName(), $formObject->getName());
116			$prefix = (false === empty($prefix))
117			? $prefix . '-'
118			: '';
119
120			$identifier = substr(
121			'fz-' . $prefix . $formIdentifier,
122			0,
123			22
124			);
125			$identifier .= '-' . md5($formObject->getHash() . $formObject->getName());
126
127			return CacheService::GENERATED_FILES_PATH . $identifier;
128			}
129
130			/**
131			* This function will check if the file at the given path exists. If it does
132			* not, the callback is called to get the content of the file, which is put
133			* in the created file.
134			*
135			* A boolean is returned: if the file did not exist, and it was created
136			* without error, `true` is returned. Otherwise, `false` is returned.
137			*
138			* @param string $relativePath
139			* @param callable $callback
140			* @return bool
141			* @throws FileCreationFailedException
142			*/
143			public function createFileInTemporaryDirectory($relativePath, callable $callback)
144			{
145			$result = false;
146			$absolutePath = GeneralUtility::getFileAbsFileName($relativePath);
147
148			if (false === $this->fileExists($absolutePath)) {
149			$content = call_user_func($callback);
150
151			$result = $this->writeTemporaryFile($absolutePath, $content);
152
153			if (null !== $result) {
154			throw FileCreationFailedException::fileCreationFailed($absolutePath, $result);
155			}
156			}
157
158			return $result;
159			}
160
161			/**
162			* This function is mocked in unit tests.
163			*
164			* @param string $absolutePath
165			* @return bool
166			*/
167			protected function fileExists($absolutePath)
168			{
169			return file_exists($absolutePath)
170			&& 0 !== filemtime($absolutePath);
171			}
172
173			/**
174			* This function is mocked in unit tests.
175			*
176			* @param string $absolutePath
177			* @param string $content
178			* @return bool
179			*/
180			protected function writeTemporaryFile($absolutePath, $content)
181			{
182			return GeneralUtility::writeFileToTypo3tempDir($absolutePath, $content);
183			}
184
185			/**
186			* @return PageRenderer
187			*/
188			public function getPageRenderer()
189			{
190			return $this->pageRenderer;
191			}
192
193			/**
194			* @return AssetHandlerFactory
195			*/
196			public function getAssetHandlerFactory()
197			{
198			return $this->assetHandlerFactory;
199			}
200
201			/**
202			* @return AssetHandlerConnectorStates
203			*/
204			public function getAssetHandlerConnectorStates()
205			{
206			return $this->assetHandlerConnectorStates;
207			}
208
209			/**
210			* @return JavaScriptAssetHandlerConnector
211			*/
212			public function getJavaScriptAssetHandlerConnector()
213			{
214			return $this->javaScriptAssetHandlerConnector;
215			}
216
217			/**
218			* @return CssAssetHandlerConnector
219			*/
220			public function getCssAssetHandlerConnector()
221			{
222			return $this->cssAssetHandlerConnector;
223			}
224
225			/**
226			* @param AssetHandlerConnectorStates $assetHandlerConnectorStates
227			*/
228			public function injectAssetHandlerConnectorStates(AssetHandlerConnectorStates $assetHandlerConnectorStates)
229			{
230			$this->assetHandlerConnectorStates = $assetHandlerConnectorStates;
231			}
232			}
233

romm / formz

getJavaScriptAssetHandlerConnector() A last analyzed 2018-11-19 14:36 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

getJavaScriptAssetHandlerConnector() A
last analyzed 2018-11-19 14:36 UTC