Minify::getMinifiedContent() - Code Metrics - Inspection of "refactor and comments" - makehappen/autominifier - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0f6a93...6e5cb2 )

by Florin

created 2017-05-30 00:08 UTC

Minify::getMinifiedContent() A

↳ Parent: Minify

Complexity

Conditions	3
Paths	3

Size

Total Lines	18
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	18
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	7
nc	3
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;

    /**
     * @var
     */
    protected $objConfig;

    /**
     * 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();
        $this->loadConfig();
        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()
    {
        // loop through all files
        $strMinifiedFileContents = '';
        foreach ($this->getFiles() 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 files to minify and concatenate
     *
     * @return array
     */
    public function getFiles()
    {
        // if list of files found in config, return them
        if (count($this->objConfig->files)) {
            return $this->objConfig->files;
        }

        // abort if folder not found
        if (!is_dir($this->getFilesFolder())) {
            return [];
        }

        // get all files
        return scandir($this->getFilesFolder());
    }

    /**
     * Get minified Content
     *
     * @param $strFileName
     * @return bool|string
     */
    public function getMinifiedContent($strFileName)
    {
        // make sure the file name it's valid
        if (!$this->isValidFileName($strFileName)) {
            return '';
        }

        // 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 a valid file name
     *
     * @param $strFileName
     * @return bool
     */
    public function isValidFileName($strFileName)
    {
        // get file extension
        $arrFileName = explode('.', $strFileName);
        $strFileExtension = array_pop($arrFileName);

        // must be a listed file type
        if (!in_array($strFileExtension, $this->arrFileTypes[$this->getDestinationExtension()])) {
            return false;
        }

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

        return true;
    }

    /**
     * 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;
    }

    /**
     * Load configuration
     */
    public function loadConfig()
    {
        // default config
        $arrDefaultConfig = [
            'files' => []
        ];

        // set config
        $this->objConfig = $this->objEnvironment->getSettings(
            $this->getFilesFolder() . '/' . Environment::CONFIG_FILE,
            $arrDefaultConfig
        );

        // set environment
        $this->objEnvironment->setEnvironment($this->getFilesFolder());
    }

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

makehappen / autominifier

Push — master ( 0f6a93...6e5cb2 )

Minify::getMinifiedContent() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like