Columnis\Service\PageBreakpointService

Complexity

Total Complexity

26

Size/Duplication

Total Lines	218
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getTemplatesPathStack()	0	3	1
A	setTemplatesPathStack()	0	3	1
A	getAssetsManagerPathStack()	0	3	1
A	setAssetsManagerPathStack()	0	3	1
A	getSmarty()	0	3	1
A	setSmarty()	0	3	1
A	__construct()	0	5	1
A	createPageBreakpoint()	0	20	3
A	loadBreakpointsPath()	0	6	2
A	checkBreakpointPath()	0	8	2
A	getCurrentBreakpointFilename()	0	8	3
A	getBreakpointTemplateHash()	0	8	2
A	createBreakpointFile()	0	20	3
A	invalidateCurrentBreakpointFile()	0	12	4

<?php

namespace Columnis\Service;

use Columnis\Model\PageBreakpoint;
use \Smarty;
use \CssMin;

class PageBreakpointService {

    /**
     * @var array The templates paths
     */
    protected $templatesPathStack = array();

    /**
     * @var array The assets manager paths
     */
    protected $assetsManagerPathStack = array();

    /**
     * Smarty object
     * 
     * @var Smarty 
     */
    protected $smarty;

    /**
     * Retrieve paths to templates
     *
     * @return array
     */
    public function getTemplatesPathStack() {
        return $this->templatesPathStack;
    }

    /**
     * Set the templates paths
     *
     * @param array $templatesPathStack
     */
    public function setTemplatesPathStack(Array $templatesPathStack) {
        $this->templatesPathStack = $templatesPathStack;
    }

    /**
     * Retrieve paths to assets manager
     * 
     * @return array
     */
    function getAssetsManagerPathStack() {

It is generally recommended to explicitly declare the visibility for methods.

        return $this->assetsManagerPathStack;
    }

    /**
     * Set the assets manager paths
     * 
     * @param array $assetsManagerPathStack
     */
    function setAssetsManagerPathStack($assetsManagerPathStack) {

It is generally recommended to explicitly declare the visibility for methods.

        $this->assetsManagerPathStack = $assetsManagerPathStack;
    }

    /**
     * Return Smarty Object
     * 
     * @return Smarty
     */
    function getSmarty() {

It is generally recommended to explicitly declare the visibility for methods.

        return $this->smarty;
    }

    /**
     * Set the Smarty Object
     * @param Smarty $smarty
     */
    function setSmarty(Smarty $smarty) {

It is generally recommended to explicitly declare the visibility for methods.

        $this->smarty = $smarty;
    }

    /**
     * Constructor
     * 
     * @param Smarty $smarty
     * @param array $templatesPathStack
     * @param array $assetsManagerPathStack
     */
    function __construct(Smarty $smarty, $templatesPathStack, $assetsManagerPathStack) {

It is generally recommended to explicitly declare the visibility for methods.

        $this->smarty = $smarty;
        $this->templatesPathStack = $templatesPathStack;
        $this->assetsManagerPathStack = $assetsManagerPathStack;
    }

    /**
     * Creats a PageBreakpoint file if not exist
     *
     * @param int $idPage
     * @param array $extraData
     * @param string $hash
     * @param array $images
     * @param array $imageSizesGroups
     * @return string
     */
    public function createPageBreakpoint($idPage, $extraData, $hash, $images, $imageSizesGroups) {
        $pageBreakpoint = new PageBreakpoint();
        $pageBreakpoint->setHash($hash);
        $pageBreakpoint->setIdPage($idPage);
        $pageBreakpoint->setExtraData($extraData);
        $pageBreakpoint->setImages($images);
        $pageBreakpoint->setTemplateHash($this->getBreakpointTemplateHash());
        $pageBreakpoint->setImageGroupsSizes($imageSizesGroups);
        $this->loadBreakpointsPath($pageBreakpoint); //Sets path
        $pathExist = $this->checkBreakpointPath($pageBreakpoint); //Check path exist, if not create it
        $currentBreakpointName = $this->getCurrentBreakpointFilename($idPage, $pageBreakpoint);
        $breakpointChange = $currentBreakpointName !== $pageBreakpoint->getFileName();
        if(!$pathExist || $breakpointChange) {
            //Invalidate last file
            $this->invalidateCurrentBreakpointFile($pageBreakpoint, $currentBreakpointName);

It seems like $currentBreakpointName defined by $this->getCurrentBreakpointFilename($idPage, $pageBreakpoint) on line 114 can also be of type false; however, Columnis\Service\PageBreakpointService::invalidateCurrentBreakpointFile() does only seem to accept string, did you maybe forget to handle an error condition?

            //Create it if path not exist (css/breakpoint dir) or the current file are diferent with the parameters
            $this->createBreakpointFile($pageBreakpoint);
        }
        return $pageBreakpoint->getFileName();
    }

    /**
     * Sets the path to pageBreakpoint object
     * 
     * @param PageBreakpoint $pageBreakpoint
     */
    protected function loadBreakpointsPath(PageBreakpoint &$pageBreakpoint) {
        $assetsPaths = $this->getAssetsManagerPathStack();
        if(is_array($assetsPaths)) {
            $pageBreakpoint->setPath($assetsPaths[1]);
        }
    }

    /**
     * Check Breakpoints directory, if not exist create it
     * 
     * @param PageBreakpoint $pageBreakpoint
     * @return boolean
     */
    protected function checkBreakpointPath(PageBreakpoint &$pageBreakpoint) {
        $path = $pageBreakpoint->getFullPath();
        if(!file_exists($path)) {
            mkdir($path);
            return false;
        }
        return true;
    }

    /**
     * Search on breakpoints dir the current breakpoint page file
     * 
     * @param int $idPage
     * @param PageBreakpoint $pageBreakpoint
     * @return boolean
     */
    protected function getCurrentBreakpointFilename($idPage, PageBreakpoint $pageBreakpoint) {
        $breakpointFiles = glob($pageBreakpoint->getFullPath().$idPage."-*.css");
        if(is_array($breakpointFiles) && count($breakpointFiles)) {
            $breakpointFile = basename(array_pop($breakpointFiles));
            return $breakpointFile;
        }
        return false;
    }

    /**
     * Get the template file hash
     * 
     * @return string
     */
    protected function getBreakpointTemplateHash() {
        $templatesPath = $this->getTemplatesPathStack()[1];
        $templateFile = $templatesPath.DIRECTORY_SEPARATOR.PageBreakpoint::BREAKPOINT_FILE;
        if(file_exists($templateFile)) {
            $hash = md5_file($templateFile);
        }
        return $hash;

The variable $hash does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * Create a new PageBreakpointFile
     * 
     * @param PageBreakpoint $pageBreakpoint
     */
    protected function createBreakpointFile(PageBreakpoint $pageBreakpoint) {
        try {
            //TemplatesConfig
            $templatesPath = $this->getTemplatesPathStack()[1];
            if(file_exists($templatesPath.DIRECTORY_SEPARATOR.PageBreakpoint::BREAKPOINT_FILE)) {
                //Get smarty object
                $smarty = $this->getSmarty();
                //Set templates path
                $smarty->setTemplateDir($templatesPath);
                //Assign data
                $smarty->assign('data', $pageBreakpoint->getData());
                //Fetch content
                $breakpointContent = $smarty->fetch(PageBreakpoint::BREAKPOINT_FILE);
                // write to file 
                file_put_contents($pageBreakpoint->getFullFileName(), CssMin::minify($breakpointContent));
            }
        } catch(\Exception $exc) {
            
        }
    }

    /**
     * Remove the last breakpoint file
     * 
     * @param PageBreakpoint $pageBreakpoint
     * @param string $currentFileName
     */
    protected function invalidateCurrentBreakpointFile(PageBreakpoint $pageBreakpoint, $currentFileName) {
        try {
            //Parse full current breakpoint name
            $invalidatePath = $pageBreakpoint->getFullPath().$currentFileName;
            //If exist delete it
            if(file_exists($invalidatePath) && is_file($invalidatePath)) {
                unlink($invalidatePath);
            }
        } catch(\Exception $exc) {

Consider adding a comment why this CATCH block is empty.

            
        }
    }
}