AssetBuilder::saveAsset() - Code Metrics - Inspection of "bugfix сохранение ассета в несуществующую папку" - DmitryNaum/SAM - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 188538...1de6e2 )

by Dmitry

created 2016-04-10 12:51 UTC

AssetBuilder::saveAsset() A

↳ Parent: AssetBuilder

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Dmitrynaum\SAM;

use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use Dmitrynaum\SAM\Component\Manifest;

/**
 * Класс для построения (компиляции) asset`ов
 *
 * @author Naumov Dmitry <[email protected]>
 */
class AssetBuilder
{

    /**
     * Флаг "Заморозить asset`ы"
     * @var bool
     */
    protected $needFreeze;
    
    /**
     * Флаг "Сжать asset`ы"
     * @var bool
     */
    protected $needCompress;
    
    /**
     * Manifest
     * @var Manifest
     */
    protected $manifest;
    
    /**
     * Путь до файла sam.json
     * @var string
     */
    protected $manifestFilePath;

    /**
     * @param string $manifestFilePath - Путь до файла sam.json
     */
    public function __construct($manifestFilePath)
    {
        $this->manifestFilePath = $manifestFilePath;
        $this->needCompress     = false;
        $this->needFreeze       = false;
    }

    /**
     * Включить заморозку asset`ов
     */
    public function enableFreezing()
    {
        $this->needFreeze = true;
    }

    /**
     * Выключить заморозку asset`ов
     */
    public function disableFreezing()
    {
        $this->needFreeze = false;
    }

    /**
     * Включена ли заморозка asset`ов
     */
    public function isFreezingEnabled()
    {
        return $this->needFreeze;
    }

    /**
     * Включить сжатие asset`ов
     */
    public function enableCompressor()
    {
        $this->needCompress = true;
    }

    /**
     * Выключить сжатие asset`ов
     */
    public function disableCompressor()
    {
        $this->needCompress = false;
    }

    /**
     * Включиено ли сжатие asset`ов
     */
    public function isCompressorEnabled()
    {
        return $this->needCompress;
    }

    /**
     * Собрать asset`ы (скомпилировать)
     */
    public function build()
    {
        $this->clearAssetDirectory();
        $this->buildCss();
        $this->buildJs();
        $this->resultMap()->save();
    }

    /**
     * Очистить папку с asset`ами
     */
    protected function clearAssetDirectory()
    {
        // Получаем путь до папки с скомпилированными asset`ами
        $assetBasePath = $this->manifest()->getAssetBasePath();
        
        // Получием список всех вложенных папок и объектов
        $dirIterator   = new RecursiveDirectoryIterator($assetBasePath, RecursiveDirectoryIterator::SKIP_DOTS);
        $files         = new RecursiveIteratorIterator($dirIterator, RecursiveIteratorIterator::CHILD_FIRST);
        
        // Удаляем все вложенные файлы и объекты
        foreach ($files as $file) {
            if ($file->isDir()) {
                rmdir($file->getPathname());
            } else {
                unlink($file->getPathname());
            }
        }
    }

    /**
     * Скомпилировать css asset`ы
     */
    protected function buildCss()
    {
        $cssAssets = $this->manifest()->getCssAssets();

        $this->buildAssets($cssAssets);
    }

    /**
     * Скомпилировать JavaScript asset`ы
     */
    protected function buildJs()
    {
        $jsAssets = $this->manifest()->getJsAssets();

        $this->buildAssets($jsAssets);
    }

    /**
     * Скомпилировать asset`ы
     * @param string[] $assets Список asset`ов для компиляции
     */
    protected function buildAssets($assets)
    {
        // Получаем карту ассетов [имя_ассета => [список файлов]]
        $assetsPaths = $this->getFilesPaths($assets);
        
        // Обходим все asset`ы
        foreach ($assetsPaths as $assetName => $assetFiles) {
            // Считываем содержимое файлов которые необходимо объежинить в asset
            $assetContent = $this->readFiles($assetFiles);

            // Вычисляем путь до файла куда будет сохранен asset
            $assetPath = $this->manifest()->getAssetBasePath() . '/' . $assetName;
            
            // Если необходимо сжать asset`ы
            if ($this->isCompressorEnabled()) {
                // Получаем объект для минимфикации
                $compressor = $this->getCompressor($assetName);
                
                // Сообщаем ему что необходимо минимфицировать
                $compressor->add($assetContent);
                
                // Минифицируем ассет
                $assetContent = $compressor->minify();
            }

            // Если необходимо заморозить
            if ($this->isFreezingEnabled()) {
                // Вычисляем путь до файла в который будет сохранен asset
                $assetHash = sha1($assetContent);
                $assetPath = $this->getFreezingAssetFileName($assetName, $assetHash);
            }
            
            // Сохраняем asset
            $this->saveAsset($assetPath, $assetContent);

            // Добавляем путь до asset файла в карту asset`ов
            $this->resultMap()->addAsset($assetName, $assetPath);
        }
    }
    
    /**
     * Сохранить ассет в файл
     * @param string $assetPath путь до файла
     * @param string $content контент
     */
    protected function saveAsset($assetPath, $content)
    {
        $dirName = dirname($assetPath);
        
        if (!is_dir($dirName)) {
            mkdir($dirName, 0777, true);
        }
        
        file_put_contents($assetPath, $content);
    }
    
    /**
     * Получить список asset`ов и файлы которые в них используются
     * @param array $assets
     * @return array список файлов используемых в ассетах
     */
    protected function getFilesPaths($assets)
    {
        $assetFilePaths = [];
        foreach ($assets as $assetName => $assetFiles) {
            $assetFilePaths[$assetName] = $this->resolveAssetFilesPaths($assets, $assetFiles);
        }
        
        return $assetFilePaths;
    }
    
    /**
     * Получить список файлов ассета
     * @param array $assets
     * @param array $assetFiles
     * @return array
     */
    protected function resolveAssetFilesPaths($assets, $assetFiles)
    {
        $assetFilePaths = [];
        // Обходим все файлы
        foreach ($assetFiles as $assetNameOrFile) {
            // Если в списке ассетов есть ассет с именем $assetNameOrFile
            if (isset($assets[$assetNameOrFile])) {
                // это имя ассета файлы которого необходимо использовать
                $assetFiles     = $assets[$assetNameOrFile];
                $assetFilePaths = array_merge($assetFilePaths, $this->resolveAssetFilesPaths($assets, $assetFiles));
            } else {
                // это путь до файла который необходимо использовать
                $assetFilePaths[] = $assetNameOrFile;
            }
        }

        return $assetFilePaths;
    }

    /**
     * Получить имя замороженного файла asset`а
     * @param string $assetName - Имя asset`а
     * @param string $assetHash - Хэш asset`а
     * @return string
     */
    protected function getFreezingAssetFileName($assetName, $assetHash)
    {
        $fileInfo = pathinfo($assetName);
        $fileName = $fileInfo['filename'] . '-' . $assetHash . '.' . $fileInfo['extension'];

        return $this->manifest()->getAssetBasePath() . '/' . $fileInfo['dirname'] . '/' . $fileName;
    }

    /**
     * Получить Manifest
     * @return Manifest
     */
    protected function manifest()
    {
        if (!$this->manifest) {
            $this->manifest = new Manifest($this->manifestFilePath);
        }

        return $this->manifest;
    }

    /**
     * Получить карту asset`ов
     * @return \Dmitrynaum\SAM\Component\AssetMap
     */
    protected function resultMap()
    {
        return $this->manifest()->resultMap();
    }

    /**
     * Считать файлы и объединить
     * @param string[] $filePaths - список файлов
     * @return string
     */
    protected function readFiles($filePaths)
    {
        $filesContent = [];

        foreach ($filePaths as $filePath) {
            $filesContent[] = file_get_contents($filePath);
        }

        return join(PHP_EOL, $filesContent);
    }

    /**
     * Получить компессор asset`ов в зависимости от типа asset`а (css или js)
     * @param string $assetPath - имя asset`а
     * @return \MatthiasMullie\Minify\Minify
     */
    protected function getCompressor($assetPath)
    {
        $fileExtension = pathinfo($assetPath, PATHINFO_EXTENSION);
        $compressor    = null;

        switch ($fileExtension) {
            case 'js':
                $compressor = new \MatthiasMullie\Minify\JS();
                break;
            case 'css':
                $compressor = new \MatthiasMullie\Minify\CSS();
                break;
        }

        return $compressor;
    }
}


1			<?php
2
3			namespace Dmitrynaum\SAM;
4
5			use RecursiveDirectoryIterator;
6			use RecursiveIteratorIterator;
7			use Dmitrynaum\SAM\Component\Manifest;
8
9			/**
10			* Класс для построения (компиляции) asset`ов
11			*
12			* @author Naumov Dmitry <[email protected]>
13			*/
14			class AssetBuilder
15			{
16
17			/**
18			* Флаг "Заморозить asset`ы"
19			* @var bool
20			*/
21			protected $needFreeze;
22
23			/**
24			* Флаг "Сжать asset`ы"
25			* @var bool
26			*/
27			protected $needCompress;
28
29			/**
30			* Manifest
31			* @var Manifest
32			*/
33			protected $manifest;
34
35			/**
36			* Путь до файла sam.json
37			* @var string
38			*/
39			protected $manifestFilePath;
40
41			/**
42			* @param string $manifestFilePath - Путь до файла sam.json
43			*/
44			public function __construct($manifestFilePath)
45			{
46			$this->manifestFilePath = $manifestFilePath;
47			$this->needCompress = false;
48			$this->needFreeze = false;
49			}
50
51			/**
52			* Включить заморозку asset`ов
53			*/
54			public function enableFreezing()
55			{
56			$this->needFreeze = true;
57			}
58
59			/**
60			* Выключить заморозку asset`ов
61			*/
62			public function disableFreezing()
63			{
64			$this->needFreeze = false;
65			}
66
67			/**
68			* Включена ли заморозка asset`ов
69			*/
70			public function isFreezingEnabled()
71			{
72			return $this->needFreeze;
73			}
74
75			/**
76			* Включить сжатие asset`ов
77			*/
78			public function enableCompressor()
79			{
80			$this->needCompress = true;
81			}
82
83			/**
84			* Выключить сжатие asset`ов
85			*/
86			public function disableCompressor()
87			{
88			$this->needCompress = false;
89			}
90
91			/**
92			* Включиено ли сжатие asset`ов
93			*/
94			public function isCompressorEnabled()
95			{
96			return $this->needCompress;
97			}
98
99			/**
100			* Собрать asset`ы (скомпилировать)
101			*/
102			public function build()
103			{
104			$this->clearAssetDirectory();
105			$this->buildCss();
106			$this->buildJs();
107			$this->resultMap()->save();
108			}
109
110			/**
111			* Очистить папку с asset`ами
112			*/
113			protected function clearAssetDirectory()
114			{
115			// Получаем путь до папки с скомпилированными asset`ами
116			$assetBasePath = $this->manifest()->getAssetBasePath();
117
118			// Получием список всех вложенных папок и объектов
119			$dirIterator = new RecursiveDirectoryIterator($assetBasePath, RecursiveDirectoryIterator::SKIP_DOTS);
120			$files = new RecursiveIteratorIterator($dirIterator, RecursiveIteratorIterator::CHILD_FIRST);
121
122			// Удаляем все вложенные файлы и объекты
123			foreach ($files as $file) {
124			if ($file->isDir()) {
125			rmdir($file->getPathname());
126			} else {
127			unlink($file->getPathname());
128			}
129			}
130			}
131
132			/**
133			* Скомпилировать css asset`ы
134			*/
135			protected function buildCss()
136			{
137			$cssAssets = $this->manifest()->getCssAssets();
138
139			$this->buildAssets($cssAssets);
140			}
141
142			/**
143			* Скомпилировать JavaScript asset`ы
144			*/
145			protected function buildJs()
146			{
147			$jsAssets = $this->manifest()->getJsAssets();
148
149			$this->buildAssets($jsAssets);
150			}
151
152			/**
153			* Скомпилировать asset`ы
154			* @param string[] $assets Список asset`ов для компиляции
155			*/
156			protected function buildAssets($assets)
157			{
158			// Получаем карту ассетов [имя_ассета => [список файлов]]
159			$assetsPaths = $this->getFilesPaths($assets);
160
161			// Обходим все asset`ы
162			foreach ($assetsPaths as $assetName => $assetFiles) {
163			// Считываем содержимое файлов которые необходимо объежинить в asset
164			$assetContent = $this->readFiles($assetFiles);
165
166			// Вычисляем путь до файла куда будет сохранен asset
167			$assetPath = $this->manifest()->getAssetBasePath() . '/' . $assetName;
168
169			// Если необходимо сжать asset`ы
170			if ($this->isCompressorEnabled()) {
171			// Получаем объект для минимфикации
172			$compressor = $this->getCompressor($assetName);
173
174			// Сообщаем ему что необходимо минимфицировать
175			$compressor->add($assetContent);
176
177			// Минифицируем ассет
178			$assetContent = $compressor->minify();
179			}
180
181			// Если необходимо заморозить
182			if ($this->isFreezingEnabled()) {
183			// Вычисляем путь до файла в который будет сохранен asset
184			$assetHash = sha1($assetContent);
185			$assetPath = $this->getFreezingAssetFileName($assetName, $assetHash);
186			}
187
188			// Сохраняем asset
189			$this->saveAsset($assetPath, $assetContent);
190
191			// Добавляем путь до asset файла в карту asset`ов
192			$this->resultMap()->addAsset($assetName, $assetPath);
193			}
194			}
195
196			/**
197			* Сохранить ассет в файл
198			* @param string $assetPath путь до файла
199			* @param string $content контент
200			*/
201			protected function saveAsset($assetPath, $content)
202			{
203			$dirName = dirname($assetPath);
204
205			if (!is_dir($dirName)) {
206			mkdir($dirName, 0777, true);
207			}
208
209			file_put_contents($assetPath, $content);
210			}
211
212			/**
213			* Получить список asset`ов и файлы которые в них используются
214			* @param array $assets
215			* @return array список файлов используемых в ассетах
216			*/
217			protected function getFilesPaths($assets)
218			{
219			$assetFilePaths = [];
220			foreach ($assets as $assetName => $assetFiles) {
221			$assetFilePaths[$assetName] = $this->resolveAssetFilesPaths($assets, $assetFiles);
222			}
223
224			return $assetFilePaths;
225			}
226
227			/**
228			* Получить список файлов ассета
229			* @param array $assets
230			* @param array $assetFiles
231			* @return array
232			*/
233			protected function resolveAssetFilesPaths($assets, $assetFiles)
234			{
235			$assetFilePaths = [];
236			// Обходим все файлы
237			foreach ($assetFiles as $assetNameOrFile) {
238			// Если в списке ассетов есть ассет с именем $assetNameOrFile
239			if (isset($assets[$assetNameOrFile])) {
240			// это имя ассета файлы которого необходимо использовать
241			$assetFiles = $assets[$assetNameOrFile];
242			$assetFilePaths = array_merge($assetFilePaths, $this->resolveAssetFilesPaths($assets, $assetFiles));
243			} else {
244			// это путь до файла который необходимо использовать
245			$assetFilePaths[] = $assetNameOrFile;
246			}
247			}
248
249			return $assetFilePaths;
250			}
251
252			/**
253			* Получить имя замороженного файла asset`а
254			* @param string $assetName - Имя asset`а
255			* @param string $assetHash - Хэш asset`а
256			* @return string
257			*/
258			protected function getFreezingAssetFileName($assetName, $assetHash)
259			{
260			$fileInfo = pathinfo($assetName);
261			$fileName = $fileInfo['filename'] . '-' . $assetHash . '.' . $fileInfo['extension'];
262
263			return $this->manifest()->getAssetBasePath() . '/' . $fileInfo['dirname'] . '/' . $fileName;
264			}
265
266			/**
267			* Получить Manifest
268			* @return Manifest
269			*/
270			protected function manifest()
271			{
272			if (!$this->manifest) {
273			$this->manifest = new Manifest($this->manifestFilePath);
274			}
275
276			return $this->manifest;
277			}
278
279			/**
280			* Получить карту asset`ов
281			* @return \Dmitrynaum\SAM\Component\AssetMap
282			*/
283			protected function resultMap()
284			{
285			return $this->manifest()->resultMap();
286			}
287
288			/**
289			* Считать файлы и объединить
290			* @param string[] $filePaths - список файлов
291			* @return string
292			*/
293			protected function readFiles($filePaths)
294			{
295			$filesContent = [];
296
297			foreach ($filePaths as $filePath) {
298			$filesContent[] = file_get_contents($filePath);
299			}
300
301			return join(PHP_EOL, $filesContent);
302			}
303
304			/**
305			* Получить компессор asset`ов в зависимости от типа asset`а (css или js)
306			* @param string $assetPath - имя asset`а
307			* @return \MatthiasMullie\Minify\Minify
308			*/
309			protected function getCompressor($assetPath)
310			{
311			$fileExtension = pathinfo($assetPath, PATHINFO_EXTENSION);
312			$compressor = null;
313
314			switch ($fileExtension) {
315			case 'js':
316			$compressor = new \MatthiasMullie\Minify\JS();
317			break;
318			case 'css':
319			$compressor = new \MatthiasMullie\Minify\CSS();
320			break;
321			}
322
323			return $compressor;
324			}
325			}
326

DmitryNaum / SAM

Push — master ( 188538...1de6e2 )

AssetBuilder::saveAsset() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like