ntentan\honam\helpers\MinifiablesHelper

Complexity

Total Complexity

21

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Coupling/Cohesion

Components	5
Dependencies	3

Test Coverage

Coverage

91.49%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
	getExtension()	0	1	?
	getMinifier()	0	1	?
	getTag()	0	1	?
A	makePublic()	0	4	1
A	context()	0	5	1
A	combine()	0	5	1
A	setContext()	0	4	1
A	setCombine()	0	4	1
A	writeTags()	0	9	2
B	__toString()	0	26	4
B	help()	0	16	5
B	add()	0	15	5

<?php
namespace ntentan\honam\helpers;

use ntentan\honam\Helper;
use ntentan\honam\AssetsLoader;
use ntentan\honam\helpers\minifiables\Minifier;

abstract class MinifiablesHelper extends Helper
{
    private $minifiableScripts = array();
    private $otherScripts = array();
    private $context = 'default';
    private $combine = false;

    protected abstract function getExtension();

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

The abstract declaration must precede the visibility declaration

    protected abstract function getMinifier();

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

The abstract declaration must precede the visibility declaration

    protected abstract function getTag($url);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

The abstract declaration must precede the visibility declaration

    
    private function makePublic($file)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->getTag(AssetsLoader::load($this->getExtension() . "/" . basename($file), $file));        
    }
    
    private function writeTags($files)
    {
        $tags = '';
        foreach($files as $script)
        {
            $tags .= $this->makePublic($script);
        }
        return $tags;
    }
    
    public function __toString()
    {
        $minifiedScript = '';
        $tags = '';
        $filename = "/" . $this->getExtension() . "/combined_{$this->context}." . $this->getExtension();
        if($this->combine === true)
        {
            foreach($this->minifiableScripts as $script)
            {
                $minifiedScript .= file_get_contents($script);
            }
            file_put_contents(AssetsLoader::getDestinationDir() . $filename, Minifier::minify($minifiedScript, $this->getMinifier()));
            $tags = $this->getTag(AssetsLoader::getSiteUrl() . $filename);
        }
        else if($this->combine == false)

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

        {
            $tags .= $this->writeTags($this->minifiableScripts);
        }
        
        $tags .= $this->writeTags($this->otherScripts);
        
        $this->minifiableScripts = array();
        $this->otherScripts = array();
        
        return $tags;
    }

    public function help($arguments)
    {
        if(is_array($arguments))
        {
            foreach($arguments as $argument)
            {
                if($argument == '') continue;
                $this->otherScripts[]= $argument;
            }
        }
        else if($arguments != '')
        {
            $this->otherScripts[]= $arguments;
        }
        return $this;
    }

    public function add($script)
    {
        if($script != '' && is_string($script))
        { 
            $this->minifiableScripts[] = $script;
        }
        else if(is_array($script))
        {
            foreach($script as $scriptFile)
            {
                $this->minifiableScripts[] = $scriptFile;
            }
        }
        return $this;
    }
    
    public function setContext($context)
    {
        return $this->context($context);
    }
    
    public function setCombine($combine)
    {
        return $this->combine($combine);
    }
    
    public function context($context)
    {
        $this->context = $context;
        return $this;
    }
    
    public function combine($combine)
    {
        $this->combine = $combine;
        return $this;
    }    
}