Minify::isAcceptedExtension() - Code Metrics - Inspection of "refactor code to reduce complexity" - makehappen/autominifier - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d12e49...53a84e )

by Florin

created 2017-05-28 20:02 UTC

Minify::isAcceptedExtension() A

↳ Parent: Minify

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

namespace Makehappen\AutoMinifier;

use MatthiasMullie\Minify as Minifier;

/**
 * Class Minify
 *
 * Automatically Minify and Concatenate your JS and CSS files and libraries into single files
 * for improved application performance.
 *
 * @package Makehappen\AutoMinifier
 */
class Minify
{
    /**
     * @var Environment
     */
    protected $objEnvironment;

    /**
     * Cache bust file path
     *
     * @var string
     */
    protected $strCacheBustFile;

    /**
     * Public folder path
     *
     * @var string
     */
    protected $strPublicFolderPath;

    /**
     * File types supported
     *
     * @var array
     */
    protected $arrFileTypes;

    /**
     * Destination file extension
     *
     * @var string
     */
    protected $strDestinationExtension;

    /**
     * Destination folder
     *
     * @var
     */
    protected $strDestinationFolder;

    /**
     * Destination file
     *
     * @var
     */
    protected $strDestinationFile;

    /**
     * Set env to dev
     *
     * @var
     */
    protected $blnIsDev;

    /**
     * Create a new Minifier Instance
     *
     * Minify constructor.
     */
    public function __construct()
    {
        // set class variables
        $this->init();

        // set environment
        $this->objEnvironment = new Environment();
    }


    /**
     * Set Class Variables
     *
     * @return null
     */
    public function init()
    {
        // set public folder location
        $this->setPublicFolder();

        // set file types we want minified
        $this->arrFileTypes = [
            'js' => ['js'],
            'css' => ['css', 'sass', 'scss']
        ];

        return null;
    }

    /**
     * Build minified file
     *
     * @var $strFolder string
     * @var $strFile string
     * @return string
     */
    public function js($strFolder = '/js', $strFile = 'app.min.js')
    {
        return $this->getMinifiedFile($strType = 'js', $strFolder, $strFile);
    }

    /**
     * Build CSS minified file
     *
     * @var $strFolder string
     * @var $strFile string
     * @return bool|null|string
     */
    public function css($strFolder = '/css', $strFile = 'app.min.css')
    {
        return $this->getMinifiedFile($strType = 'css', $strFolder, $strFile);
    }
    
    /**
     * Generate minified file
     *
     * @param string $strType
     * @param string $strFolder
     * @param string $strFile
     * @return string
     */
    public function getMinifiedFile($strType = 'css', $strFolder = '/css', $strFile = 'app.min.css')
    {
        $this->setDestinationExtensionType($strType);
        $this->setDestinationFolder($strFolder);
        $this->setDestinationFile($strFile);
        $this->setCacheBustFile();
        return $strFolder . '/' . $strFile .'?' . $this->process();
    }

    /**
     * Process Built
     *
     * @return bool|null|string
     */
    public function process()
    {
        // return last cache bust in non development environments
        if (!$this->objEnvironment->isDevEnv()) {
            return $this->getCacheBust();
        }

        // build application file
        $strApplicationFileContents = $this->build();

        // save application file
        file_put_contents($this->getAppFileName(), $strApplicationFileContents);

        // save new cache bust
        return $this->saveCacheBust($strApplicationFileContents);
    }

    /**
     * Build file
     *
     * @return string
     */
    public function build()
    {
        // files folder
        $strFilesFolder = $this->getFilesFolder();

        // abort if folder not found
        if (!is_dir($strFilesFolder)) {
            return $strFilesFolder . ' folder not found';
        }

        // get all files
        $arrFiles = scandir($strFilesFolder);

        // loop through all files
        $strMinifiedFileContents = '';
        foreach ($arrFiles as $strFileName) {
            // get minified content
            $strFileContents = $this->getMinifiedContent($strFileName);

            // don't include empty files
            if (!$strFileContents) {
                continue;
            }

            // add new minified file to concatenated version
            $strMinifiedFileContents .= "\n/* $strFileName */\n" . $strFileContents;
        }

        // returned concatenated version of minifired files
        return $strMinifiedFileContents;
    }

    /**
     * Get minified Content
     *
     * @param $strFileName
     * @return null|string
     */
    public function getMinifiedContent($strFileName)
    {
        // get file extension
        $strFileExtension = array_pop(explode('.', $strFileName));


        // must be an accepted file type
        if (!$this->isAcceptedExtension($strFileExtension)) {
            return null;
        }

        // must not be the app file
        if ($strFileName == $this->getDestinationFile()) {
            return null;
        }

        // build file path and name
        $strFile = $this->getFilesFolder() . '/' . $strFileName;

        // if it's minified already return content
        if (preg_match('/\.min\./', $strFile)) {
            return file_get_contents($strFile);
        }

        // return minified content
        return $this->minifyContent($strFile);
    }

    /**
     * Determine if it's an accepted extension
     *
     * @param $strFileExtension
     * @return bool
     */
    public function isAcceptedExtension($strFileExtension)
    {
        return in_array($strFileExtension, $this->arrFileTypes[$this->getDestinationExtension()]);
    }

    /**
     * Minify content
     *
     * @param  $strFile
     * @return bool|string
     */
    public function minifyContent($strFile)
    {
        // minify based on file type
        switch ($this->getDestinationExtension()) {
            case 'js':
                return (new Minifier\JS($strFile))->minify();
            case 'css':
                return (new Minifier\CSS($strFile))->minify();
            default:
                return '';
        }
    }

    /**
     * Save Cache Bust
     *
     * @var string $strApplicationFileContents
     * @return null
     */
    public function saveCacheBust($strApplicationFileContents = '')
    {
        // get contents signature
        $strNewCacheBust = md5($strApplicationFileContents);

        // get prior cache bust
        $strPriorCacheBust = $this->getCacheBust();

        // if unchanged, stop here
        if ($strPriorCacheBust == $strNewCacheBust) {
            return $strPriorCacheBust;
        }

        // set new cache bust
        file_put_contents($this->strCacheBustFile, $strNewCacheBust);

        // return new cache bust
        return $strNewCacheBust;
    }

    /**
     * Get Cache Bust
     *
     * @return bool|string
     */
    public function getCacheBust()
    {
        // abort if file not found
        if (!file_exists($this->strCacheBustFile)) {
            return '';
        }

        // get cache bust file contents
        return file_get_contents($this->strCacheBustFile);
    }

    /**
     * Set env to Dev
     *
     * @param bool $bln
     * @return $this
     */
    public function setDev($bln = true)
    {
        $this->objEnvironment->setDev($bln);
        $this->blnIsDev = $bln;
        return $this;
    }

    /**
     * Set Cache bust file
     *
     * @param string $strFile
     * @return $this
     */
    public function setCacheBustFile($strFile = 'autominifier-cache-bust.txt')
    {
        $this->strCacheBustFile = $this->getFilesFolder() . "/$strFile";
        return $this;
    }

    /**
     * Set public folder
     *
     * @param string $strFolder
     * @return $this
     */
    public function setPublicFolder($strFolder = '/../../../../public')
    {
        // set application public path relative to package location
        $this->strPublicFolderPath = __DIR__ . $strFolder;
        return $this;
    }

    /**
     * Set test folder
     *
     * @return $this
     */
    public function setTest()
    {
        // set application public path relative to package location
        $this->setPublicFolder('/../build');

        // cache bust file
        $this->setCacheBustFile();

        return $this;
    }

    /**
     * Set destination folder
     *
     * @param $strFolder
     * @return $this
     */
    public function setDestinationFolder($strFolder)
    {
        $this->strDestinationFolder = $strFolder;
        return $this;
    }

    /**
     * Set destination file
     *
     * @param $strFile
     * @return $this
     */
    public function setDestinationFile($strFile)
    {
        $this->strDestinationFile = $strFile;
        return $this;
    }

    /**
     * Set destination file extension
     *
     * @param $strDestinationExtension
     */
    public function setDestinationExtensionType($strDestinationExtension)
    {
        $this->strDestinationExtension = $strDestinationExtension;
    }

    /**
     * Get Public folder
     *
     * @return string
     */
    public function getPublicFolder()
    {
        return $this->strPublicFolderPath;
    }

    /**
     * Get destination folder
     *
     * @return mixed
     */
    public function getDestinationFolder()
    {
        return $this->strDestinationFolder;
    }

    /**
     * Set destination file
     *
     * @return mixed
     */
    public function getDestinationFile()
    {
        return $this->strDestinationFile;
    }

    /**
     * Get application file name
     *
     * @return string
     */
    public function getAppFileName()
    {
        return $this->getFilesFolder() . '/' . $this->getDestinationFile();
    }

    /**
     * Get destination file type extension
     *
     * @return mixed
     */
    public function getDestinationExtension()
    {
        return $this->strDestinationExtension;
    }

    /**
     * Get files folder
     *
     * @return string
     */
    public function getFilesFolder()
    {
        return $this->getPublicFolder() . '/' . $this->getDestinationFolder();
    }
}


1			<?php
2
3			namespace Makehappen\AutoMinifier;
4
5			use MatthiasMullie\Minify as Minifier;
6
7			/**
8			* Class Minify
9			*
10			* Automatically Minify and Concatenate your JS and CSS files and libraries into single files
11			* for improved application performance.
12			*
13			* @package Makehappen\AutoMinifier
14			*/
15			class Minify
16			{
17			/**
18			* @var Environment
19			*/
20			protected $objEnvironment;
21
22			/**
23			* Cache bust file path
24			*
25			* @var string
26			*/
27			protected $strCacheBustFile;
28
29			/**
30			* Public folder path
31			*
32			* @var string
33			*/
34			protected $strPublicFolderPath;
35
36			/**
37			* File types supported
38			*
39			* @var array
40			*/
41			protected $arrFileTypes;
42
43			/**
44			* Destination file extension
45			*
46			* @var string
47			*/
48			protected $strDestinationExtension;
49
50			/**
51			* Destination folder
52			*
53			* @var
54			*/
55			protected $strDestinationFolder;
56
57			/**
58			* Destination file
59			*
60			* @var
61			*/
62			protected $strDestinationFile;
63
64			/**
65			* Set env to dev
66			*
67			* @var
68			*/
69			protected $blnIsDev;
70
71			/**
72			* Create a new Minifier Instance
73			*
74			* Minify constructor.
75			*/
76			public function __construct()
77			{
78			// set class variables
79			$this->init();
80
81			// set environment
82			$this->objEnvironment = new Environment();
83			}
84
85
86			/**
87			* Set Class Variables
88			*
89			* @return null
90			*/
91			public function init()
92			{
93			// set public folder location
94			$this->setPublicFolder();
95
96			// set file types we want minified
97			$this->arrFileTypes = [
98			'js' => ['js'],
99			'css' => ['css', 'sass', 'scss']
100			];
101
102			return null;
103			}
104
105			/**
106			* Build minified file
107			*
108			* @var $strFolder string
109			* @var $strFile string
110			* @return string
111			*/
112			public function js($strFolder = '/js', $strFile = 'app.min.js')
113			{
114			return $this->getMinifiedFile($strType = 'js', $strFolder, $strFile);
115			}
116
117			/**
118			* Build CSS minified file
119			*
120			* @var $strFolder string
121			* @var $strFile string
122			* @return bool\|null\|string
123			*/
124			public function css($strFolder = '/css', $strFile = 'app.min.css')
125			{
126			return $this->getMinifiedFile($strType = 'css', $strFolder, $strFile);
127			}
128
129			/**
130			* Generate minified file
131			*
132			* @param string $strType
133			* @param string $strFolder
134			* @param string $strFile
135			* @return string
136			*/
137			public function getMinifiedFile($strType = 'css', $strFolder = '/css', $strFile = 'app.min.css')
138			{
139			$this->setDestinationExtensionType($strType);
140			$this->setDestinationFolder($strFolder);
141			$this->setDestinationFile($strFile);
142			$this->setCacheBustFile();
143			return $strFolder . '/' . $strFile .'?' . $this->process();
144			}
145
146			/**
147			* Process Built
148			*
149			* @return bool\|null\|string
150			*/
151			public function process()
152			{
153			// return last cache bust in non development environments
154			if (!$this->objEnvironment->isDevEnv()) {
155			return $this->getCacheBust();
156			}
157
158			// build application file
159			$strApplicationFileContents = $this->build();
160
161			// save application file
162			file_put_contents($this->getAppFileName(), $strApplicationFileContents);
163
164			// save new cache bust
165			return $this->saveCacheBust($strApplicationFileContents);
166			}
167
168			/**
169			* Build file
170			*
171			* @return string
172			*/
173			public function build()
174			{
175			// files folder
176			$strFilesFolder = $this->getFilesFolder();
177
178			// abort if folder not found
179			if (!is_dir($strFilesFolder)) {
180			return $strFilesFolder . ' folder not found';
181			}
182
183			// get all files
184			$arrFiles = scandir($strFilesFolder);
185
186			// loop through all files
187			$strMinifiedFileContents = '';
188			foreach ($arrFiles as $strFileName) {
189			// get minified content
190			$strFileContents = $this->getMinifiedContent($strFileName);
191
192			// don't include empty files
193			if (!$strFileContents) {
194			continue;
195			}
196
197			// add new minified file to concatenated version
198			$strMinifiedFileContents .= "\n/* $strFileName */\n" . $strFileContents;
199			}
200
201			// returned concatenated version of minifired files
202			return $strMinifiedFileContents;
203			}
204
205			/**
206			* Get minified Content
207			*
208			* @param $strFileName
209			* @return null\|string
210			*/
211			public function getMinifiedContent($strFileName)
212			{
213			// get file extension
214			$strFileExtension = array_pop(explode('.', $strFileName));
			0 ignored issues – show Bug introduced 2017-05-28 20:18 UTC by Report Bug Copy Issue Report `explode('.', $strFileName)` cannot be passed to `array_pop()` as the parameter `$array` expects a reference. Loading history...
215
216			// must be an accepted file type
217			if (!$this->isAcceptedExtension($strFileExtension)) {
218			return null;
219			}
220
221			// must not be the app file
222			if ($strFileName == $this->getDestinationFile()) {
223			return null;
224			}
225
226			// build file path and name
227			$strFile = $this->getFilesFolder() . '/' . $strFileName;
228
229			// if it's minified already return content
230			if (preg_match('/\.min\./', $strFile)) {
231			return file_get_contents($strFile);
232			}
233
234			// return minified content
235			return $this->minifyContent($strFile);
236			}
237
238			/**
239			* Determine if it's an accepted extension
240			*
241			* @param $strFileExtension
242			* @return bool
243			*/
244			public function isAcceptedExtension($strFileExtension)
245			{
246			return in_array($strFileExtension, $this->arrFileTypes[$this->getDestinationExtension()]);
247			}
248
249			/**
250			* Minify content
251			*
252			* @param $strFile
253			* @return bool\|string
254			*/
255			public function minifyContent($strFile)
256			{
257			// minify based on file type
258			switch ($this->getDestinationExtension()) {
259			case 'js':
260			return (new Minifier\JS($strFile))->minify();
261			case 'css':
262			return (new Minifier\CSS($strFile))->minify();
263			default:
264			return '';
265			}
266			}
267
268			/**
269			* Save Cache Bust
270			*
271			* @var string $strApplicationFileContents
272			* @return null
273			*/
274			public function saveCacheBust($strApplicationFileContents = '')
275			{
276			// get contents signature
277			$strNewCacheBust = md5($strApplicationFileContents);
278
279			// get prior cache bust
280			$strPriorCacheBust = $this->getCacheBust();
281
282			// if unchanged, stop here
283			if ($strPriorCacheBust == $strNewCacheBust) {
284			return $strPriorCacheBust;
285			}
286
287			// set new cache bust
288			file_put_contents($this->strCacheBustFile, $strNewCacheBust);
289
290			// return new cache bust
291			return $strNewCacheBust;
292			}
293
294			/**
295			* Get Cache Bust
296			*
297			* @return bool\|string
298			*/
299			public function getCacheBust()
300			{
301			// abort if file not found
302			if (!file_exists($this->strCacheBustFile)) {
303			return '';
304			}
305
306			// get cache bust file contents
307			return file_get_contents($this->strCacheBustFile);
308			}
309
310			/**
311			* Set env to Dev
312			*
313			* @param bool $bln
314			* @return $this
315			*/
316			public function setDev($bln = true)
317			{
318			$this->objEnvironment->setDev($bln);
319			$this->blnIsDev = $bln;
320			return $this;
321			}
322
323			/**
324			* Set Cache bust file
325			*
326			* @param string $strFile
327			* @return $this
328			*/
329			public function setCacheBustFile($strFile = 'autominifier-cache-bust.txt')
330			{
331			$this->strCacheBustFile = $this->getFilesFolder() . "/$strFile";
332			return $this;
333			}
334
335			/**
336			* Set public folder
337			*
338			* @param string $strFolder
339			* @return $this
340			*/
341			public function setPublicFolder($strFolder = '/../../../../public')
342			{
343			// set application public path relative to package location
344			$this->strPublicFolderPath = __DIR__ . $strFolder;
345			return $this;
346			}
347
348			/**
349			* Set test folder
350			*
351			* @return $this
352			*/
353			public function setTest()
354			{
355			// set application public path relative to package location
356			$this->setPublicFolder('/../build');
357
358			// cache bust file
359			$this->setCacheBustFile();
360
361			return $this;
362			}
363
364			/**
365			* Set destination folder
366			*
367			* @param $strFolder
368			* @return $this
369			*/
370			public function setDestinationFolder($strFolder)
371			{
372			$this->strDestinationFolder = $strFolder;
373			return $this;
374			}
375
376			/**
377			* Set destination file
378			*
379			* @param $strFile
380			* @return $this
381			*/
382			public function setDestinationFile($strFile)
383			{
384			$this->strDestinationFile = $strFile;
385			return $this;
386			}
387
388			/**
389			* Set destination file extension
390			*
391			* @param $strDestinationExtension
392			*/
393			public function setDestinationExtensionType($strDestinationExtension)
394			{
395			$this->strDestinationExtension = $strDestinationExtension;
396			}
397
398			/**
399			* Get Public folder
400			*
401			* @return string
402			*/
403			public function getPublicFolder()
404			{
405			return $this->strPublicFolderPath;
406			}
407
408			/**
409			* Get destination folder
410			*
411			* @return mixed
412			*/
413			public function getDestinationFolder()
414			{
415			return $this->strDestinationFolder;
416			}
417
418			/**
419			* Set destination file
420			*
421			* @return mixed
422			*/
423			public function getDestinationFile()
424			{
425			return $this->strDestinationFile;
426			}
427
428			/**
429			* Get application file name
430			*
431			* @return string
432			*/
433			public function getAppFileName()
434			{
435			return $this->getFilesFolder() . '/' . $this->getDestinationFile();
436			}
437
438			/**
439			* Get destination file type extension
440			*
441			* @return mixed
442			*/
443			public function getDestinationExtension()
444			{
445			return $this->strDestinationExtension;
446			}
447
448			/**
449			* Get files folder
450			*
451			* @return string
452			*/
453			public function getFilesFolder()
454			{
455			return $this->getPublicFolder() . '/' . $this->getDestinationFolder();
456			}
457			}
458

makehappen / autominifier

Push — master ( d12e49...53a84e )

Minify::isAcceptedExtension() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like