AssetManager::__construct() - Code Metrics - DmitryNaum/SAM - Measure and Improve Code Quality continuously with Scrutinizer

AssetManager::__construct() A
last analyzed 2016-04-19 18:04 UTC

↳ Parent: AssetManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
c	4
b	0
f	0
dl	0
loc	5
rs	9.4285
cc	1
eloc	3
nc	1
nop	1

<?php

namespace Dmitrynaum\SAM;

/**
 * Менеджер для работы с asset`ами
 *
 * @author Naumov Dmitry <[email protected]>
 */
class AssetManager
{
    /**
     * Список используемых JavaScript asset`ов
     * @var string[]
     */
    protected $js = [];
    
    /**
     * Список inline JS
     * @var array
     */
    protected $inlineJs = [];
    
    /**
     * Список используемых Css asset`ов
     * @var string[]
     */
    protected $css = [];
        
    /**
     * Список inline Css
     * @var array
     */
    protected $inlineCss = [];

    /**
     * Манифест
     * @var Component\Manifest
     */
    protected $manifest;

    /**
     * Режим разработки
     * @var bool
     */
    protected $developmentMode;
    
    /**
     * @param \Dmitrynaum\SAM\Component\AssetMap $manifest - Карта asset`ов
     */
    public function __construct(Component\Manifest $manifest)
    {
        $this->manifest        = $manifest;
        $this->developmentMode = false;
    }
    
    
    /**
     * Включить режим разработки
     */
    public function enableDevelopmentMode()
    {
        $this->developmentMode = true;
    }
    
    /**
     * Выключить режим разработки
     */
    public function disableDevelopmentMode()
    {
        $this->developmentMode = false;
    }
    
    /**
     * Включен ли режим разработки
     * @return bool
     */
    public function isDevelopmentModeEnabled()
    {
        return $this->developmentMode;
    }

    /**
     * Использовать JavaScript по названию asset`а или url
     * @param string $assetNameOrUrl - имя ассета
     */
    public function useJs($assetNameOrUrl)
    {
        if (!in_array($assetNameOrUrl, $this->js)) {
            $this->js[] = $assetNameOrUrl;
        }
    }

    /**
     * Использовать CSS по названию asset`а или url
     * @param string $assetNameOrUrl - Имя ассета
     */
    public function useCss($assetNameOrUrl)
    {
        if (!in_array($assetNameOrUrl, $this->css)) {
            $this->css[] = $assetNameOrUrl;
        }
    }
    
    /**
     * Добавить inline css код
     * @param string $css
     */
    public function addInlineCss($css)
    {
        $this->inlineCss[] = $css;
    }
    
    /**
     * Добавить inline JavaScript код
     * @param string $js
     */
    public function addInlineJs($js)
    {
        $this->inlineJs[] = $js;
    }

    /**
     * Получить html теги script с используемыми JavaScript asset`ами
     * @param array $attributes Массив атрибутов тега
     * ['type' => 'text/javascript']
     * ['async', 'defer']
     * @return string
     */
    public function renderJs(array $attributes = [])
    {
        $jsUrls = $this->getUrls($this->js);
        
        $jsTags = '';
        foreach ($jsUrls as $jsUrl) {
            $jsTags .= $this->wrapJsLink($jsUrl, $attributes);
        }

        return $jsTags;
    }

    /**
     * Получить html теги link с используемыми CSS asset`ами
     * @return string
     */
    public function renderCss()
    {
        $cssUrls = $this->getUrls($this->css);
        
        $cssTags = '';
        foreach ($cssUrls as $cssUrl) {
            $cssTags .= $this->wrapCssLink($cssUrl);
        }

        return $cssTags;
    }
    
    /**
     * Получить теги script с inline js или пустую строку если их нет
     * @return string
     */
    public function renderInlineJs()
    {
        $jsCode = join(";\n", $this->inlineJs);
        
        return $jsCode ? "<script>{$jsCode}</script>" : '';
    }
    
    /**
     * Получить теги style с inline css или пустую строку если их нет
     * @return string
     */
    public function renderInlineCss()
    {
        $cssCode = join("\n", $this->inlineCss);
        
        return $cssCode ? "<style>{$cssCode}</style>" : '';
    }
    
    /**
     * Получить используемые css ассеты и url
     * @return array
     */
    public function getUsedCss()
    {
        return $this->css;
    }
    
    /**
     * Получить используемые js asset`ы и url
     * @return array
     */
    public function getUsedJs()
    {
        return $this->js;
    }
    
    /**
     * Удалить используемый css по названию asset`а или url
     * @param string $cssAssetNameOrUrl
     */
    public function removeCss($cssAssetNameOrUrl)
    {
        foreach ($this->css as $index => $assetName) {
            if ($assetName == $cssAssetNameOrUrl) {
                unset($this->css[$index]);
            }
        }
    }
    
    /**
     * Удалить используемый js по названию asset`а или url
     * @param string $jsAssetNameOrUrl
     */
    public function removeJs($jsAssetNameOrUrl)
    {
        foreach ($this->js as $index => $assetName) {
            if ($assetName == $jsAssetNameOrUrl) {
                unset($this->js[$index]);
            }
        }
    }
    
    /**
     * Удалить все используемые css asset`ы
     */
    public function removeAllCss()
    {
        $this->css = [];
    }
    
    /**
     * Удалить все используемые js asset`ы
     */
    public function removeAllJs()
    {
        $this->js = [];
    }

    /**
     * Получить ссылку на asset по его имени
     * @param string $assetName название asset`а
     * @return string
     */
    protected function getAssetUrl($assetName)
    {
        if ($this->isDevelopmentModeEnabled()) {
            $assetUrl = "//{$this->manifest->getServerAddress()}/?asset=$assetName";
        } else {
            $assetUrl = $this->manifest->resultMap()->getAssetPath($assetName);
        }
        
        return $assetUrl;
    }
    
    /**
     * Обернуть ссылку на JS файл в тег script
     * @param string $pathToJs
     * @param array $attributes Массив атрибутов тега
     * ['Имя атрибута' => 'значение']
     * ['атрибут']
     * @return string
     */
    protected function wrapJsLink($pathToJs, array $attributes = [])
    {
        
        $attrs = [];
        foreach ($attributes as $arrtibute => $value) {
            if (is_numeric($arrtibute)) {
                $attrs[] = $value;
            } else {
                $attrs[] = "{$arrtibute}='{$value}'";
            }
        }
        
        $attributesString = join(' ', $attrs);
        return "<script src='{$pathToJs}' {$attributesString}></script>";
    }
    
    /**
     * Обернуть ссылку на Css файл в тег script
     * @param string $pathToCss
     * @return string
     */
    protected function wrapCssLink($pathToCss)
    {
        return "<link rel='stylesheet' type='text/css' href='{$pathToCss}' />";
    }
    
    /**
     * Проверяет является ли ссылка URL
     * @param string $string
     * @return bool
     */
    protected function isUrl($string)
    {
        if (strpos($string, '//') === 0) {
            $string = "http:{$string}";
        }
        
        return filter_var($string, FILTER_VALIDATE_URL) !== false;
    }
    
    /**
     * Получить ссылки
     * @param array $array
     */
    protected function getUrls($array)
    {
        $urls = [];
        foreach ($array as $assetNameOrUrl) {
            if ($this->isUrl($assetNameOrUrl)) {
                $urls[] = $assetNameOrUrl;
            } else {
                $urls[] = $this->getAssetUrl($assetNameOrUrl);
            }
        }
        
        return $urls;
    }
}


1			<?php
2
3			namespace Dmitrynaum\SAM;
4
5			/**
6			* Менеджер для работы с asset`ами
7			*
8			* @author Naumov Dmitry <[email protected]>
9			*/
10			class AssetManager
11			{
12			/**
13			* Список используемых JavaScript asset`ов
14			* @var string[]
15			*/
16			protected $js = [];
17
18			/**
19			* Список inline JS
20			* @var array
21			*/
22			protected $inlineJs = [];
23
24			/**
25			* Список используемых Css asset`ов
26			* @var string[]
27			*/
28			protected $css = [];
29
30			/**
31			* Список inline Css
32			* @var array
33			*/
34			protected $inlineCss = [];
35
36			/**
37			* Манифест
38			* @var Component\Manifest
39			*/
40			protected $manifest;
41
42			/**
43			* Режим разработки
44			* @var bool
45			*/
46			protected $developmentMode;
47
48			/**
49			* @param \Dmitrynaum\SAM\Component\AssetMap $manifest - Карта asset`ов
50			*/
51			public function __construct(Component\Manifest $manifest)
52			{
53			$this->manifest = $manifest;
54			$this->developmentMode = false;
55			}
56
57
58			/**
59			* Включить режим разработки
60			*/
61			public function enableDevelopmentMode()
62			{
63			$this->developmentMode = true;
64			}
65
66			/**
67			* Выключить режим разработки
68			*/
69			public function disableDevelopmentMode()
70			{
71			$this->developmentMode = false;
72			}
73
74			/**
75			* Включен ли режим разработки
76			* @return bool
77			*/
78			public function isDevelopmentModeEnabled()
79			{
80			return $this->developmentMode;
81			}
82
83			/**
84			* Использовать JavaScript по названию asset`а или url
85			* @param string $assetNameOrUrl - имя ассета
86			*/
87			public function useJs($assetNameOrUrl)
88			{
89			if (!in_array($assetNameOrUrl, $this->js)) {
90			$this->js[] = $assetNameOrUrl;
91			}
92			}
93
94			/**
95			* Использовать CSS по названию asset`а или url
96			* @param string $assetNameOrUrl - Имя ассета
97			*/
98			public function useCss($assetNameOrUrl)
99			{
100			if (!in_array($assetNameOrUrl, $this->css)) {
101			$this->css[] = $assetNameOrUrl;
102			}
103			}
104
105			/**
106			* Добавить inline css код
107			* @param string $css
108			*/
109			public function addInlineCss($css)
110			{
111			$this->inlineCss[] = $css;
112			}
113
114			/**
115			* Добавить inline JavaScript код
116			* @param string $js
117			*/
118			public function addInlineJs($js)
119			{
120			$this->inlineJs[] = $js;
121			}
122
123			/**
124			* Получить html теги script с используемыми JavaScript asset`ами
125			* @param array $attributes Массив атрибутов тега
126			* ['type' => 'text/javascript']
127			* ['async', 'defer']
128			* @return string
129			*/
130			public function renderJs(array $attributes = [])
131			{
132			$jsUrls = $this->getUrls($this->js);
133
134			$jsTags = '';
135			foreach ($jsUrls as $jsUrl) {
136			$jsTags .= $this->wrapJsLink($jsUrl, $attributes);
137			}
138
139			return $jsTags;
140			}
141
142			/**
143			* Получить html теги link с используемыми CSS asset`ами
144			* @return string
145			*/
146			public function renderCss()
147			{
148			$cssUrls = $this->getUrls($this->css);
149
150			$cssTags = '';
151			foreach ($cssUrls as $cssUrl) {
152			$cssTags .= $this->wrapCssLink($cssUrl);
153			}
154
155			return $cssTags;
156			}
157
158			/**
159			* Получить теги script с inline js или пустую строку если их нет
160			* @return string
161			*/
162			public function renderInlineJs()
163			{
164			$jsCode = join(";\n", $this->inlineJs);
165
166			return $jsCode ? "<script>{$jsCode}</script>" : '';
167			}
168
169			/**
170			* Получить теги style с inline css или пустую строку если их нет
171			* @return string
172			*/
173			public function renderInlineCss()
174			{
175			$cssCode = join("\n", $this->inlineCss);
176
177			return $cssCode ? "<style>{$cssCode}</style>" : '';
178			}
179
180			/**
181			* Получить используемые css ассеты и url
182			* @return array
183			*/
184			public function getUsedCss()
185			{
186			return $this->css;
187			}
188
189			/**
190			* Получить используемые js asset`ы и url
191			* @return array
192			*/
193			public function getUsedJs()
194			{
195			return $this->js;
196			}
197
198			/**
199			* Удалить используемый css по названию asset`а или url
200			* @param string $cssAssetNameOrUrl
201			*/
202			public function removeCss($cssAssetNameOrUrl)
203			{
204			foreach ($this->css as $index => $assetName) {
205			if ($assetName == $cssAssetNameOrUrl) {
206			unset($this->css[$index]);
207			}
208			}
209			}
210
211			/**
212			* Удалить используемый js по названию asset`а или url
213			* @param string $jsAssetNameOrUrl
214			*/
215			public function removeJs($jsAssetNameOrUrl)
216			{
217			foreach ($this->js as $index => $assetName) {
218			if ($assetName == $jsAssetNameOrUrl) {
219			unset($this->js[$index]);
220			}
221			}
222			}
223
224			/**
225			* Удалить все используемые css asset`ы
226			*/
227			public function removeAllCss()
228			{
229			$this->css = [];
230			}
231
232			/**
233			* Удалить все используемые js asset`ы
234			*/
235			public function removeAllJs()
236			{
237			$this->js = [];
238			}
239
240			/**
241			* Получить ссылку на asset по его имени
242			* @param string $assetName название asset`а
243			* @return string
244			*/
245			protected function getAssetUrl($assetName)
246			{
247			if ($this->isDevelopmentModeEnabled()) {
248			$assetUrl = "//{$this->manifest->getServerAddress()}/?asset=$assetName";
249			} else {
250			$assetUrl = $this->manifest->resultMap()->getAssetPath($assetName);
251			}
252
253			return $assetUrl;
254			}
255
256			/**
257			* Обернуть ссылку на JS файл в тег script
258			* @param string $pathToJs
259			* @param array $attributes Массив атрибутов тега
260			* ['Имя атрибута' => 'значение']
261			* ['атрибут']
262			* @return string
263			*/
264			protected function wrapJsLink($pathToJs, array $attributes = [])
265			{
266
267			$attrs = [];
268			foreach ($attributes as $arrtibute => $value) {
269			if (is_numeric($arrtibute)) {
270			$attrs[] = $value;
271			} else {
272			$attrs[] = "{$arrtibute}='{$value}'";
273			}
274			}
275
276			$attributesString = join(' ', $attrs);
277			return "<script src='{$pathToJs}' {$attributesString}></script>";
278			}
279
280			/**
281			* Обернуть ссылку на Css файл в тег script
282			* @param string $pathToCss
283			* @return string
284			*/
285			protected function wrapCssLink($pathToCss)
286			{
287			return "<link rel='stylesheet' type='text/css' href='{$pathToCss}' />";
288			}
289
290			/**
291			* Проверяет является ли ссылка URL
292			* @param string $string
293			* @return bool
294			*/
295			protected function isUrl($string)
296			{
297			if (strpos($string, '//') === 0) {
298			$string = "http:{$string}";
299			}
300
301			return filter_var($string, FILTER_VALIDATE_URL) !== false;
302			}
303
304			/**
305			* Получить ссылки
306			* @param array $array
307			*/
308			protected function getUrls($array)
309			{
310			$urls = [];
311			foreach ($array as $assetNameOrUrl) {
312			if ($this->isUrl($assetNameOrUrl)) {
313			$urls[] = $assetNameOrUrl;
314			} else {
315			$urls[] = $this->getAssetUrl($assetNameOrUrl);
316			}
317			}
318
319			return $urls;
320			}
321			}
322

DmitryNaum / SAM

AssetManager::__construct() A last analyzed 2016-04-19 18:04 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AssetManager::__construct() A
last analyzed 2016-04-19 18:04 UTC