BFW\Install\Application

Complexity

Total Complexity

18

Size/Duplication

Total Lines	125
Duplicated Lines	12 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	initRequest()	0	4	1
A	initSession()	0	4	1
A	initErrors()	0	4	1
A	addModuleInstall()	0	6	1
A	declareRunSteps()	0	8	1
A	run()	15	15	3
B	installModules()	0	18	5
B	installModule()	0	24	5

<?php

namespace BFW\Install;

use \BFW\Install\ModuleInstall;

/**
 * Application class for install module script
 */
class Application extends \BFW\Application
{
    /**
     * @var \BFW\Install\ModuleInstall[] $modulesInstall Modules to install
     */
    protected static $modulesInstall = [];
    
    /**
     * {@inheritdoc}
     */
    protected function initRequest()
    {
        return;
    }

    /**
     * {@inheritdoc}
     */
    protected function initSession()
    {
        return;
    }

    /**
     * {@inheritdoc}
     */
    protected function initErrors()
    {
        return;
    }
    
    public static function addModuleInstall(ModuleInstall $module)
    {
        $moduleName = $module->getName();
        
        self::$modulesInstall[$moduleName] = $module;
    }

    /**
     * {@inheritdoc}
     */
    protected function declareRunSteps()
    {
        $this->runSteps = [
            [$this, 'loadMemcached'],
            [$this, 'readAllModules'],
            [$this, 'installModules']
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function run()

This method seems to be duplicated in your project.

    {
        foreach ($this->runSteps as $action) {
            $action();

            $notifyAction = $action;
            if (is_array($action)) {
                $notifyAction = $action[1];
            }

            $this->notifyAction('bfw_modules_install_run_'.$notifyAction);
        }

        $this->notifyAction('bfw_modules_install_finish');
    }
    
    /**
     * Install all modules in the order of the dependency tree.
     * 
     * @return void
     */
    protected function installModules()
    {
        echo 'Read all modules to run install script :'."\n";
        
        $tree = $this->modules->getLoadTree();

        foreach ($tree as $firstLine) {
            foreach ($firstLine as $secondLine) {
                foreach ($secondLine as $moduleName) {
                    if (!isset(self::$modulesInstall[$moduleName])) {
                        continue;
                    }
                    
                    $this->installModule($moduleName);
                }
            }
        }
    }
    
    /**
     * Install a module
     * 
     * @param string $moduleName The module name
     * 
     * @return void
     */
    protected function installModule($moduleName)
    {
        if (!isset(self::$modulesInstall[$moduleName])) {
            return;
        }
        
        echo ' > Read for module '.$moduleName."\n";
        
        $module         = self::$modulesInstall[$moduleName];
        $installScripts = $module->getSourceInstallScript();
        
        if ($installScripts === '') {
            echo ' >> No script to run.'."\n";
            return;
        }
        
        if (is_string($installScripts)) {
            $installScripts = (array) $installScripts;
        }
        
        foreach ($installScripts as $scriptPath) {

The expression $installScripts of type array|boolean is not guaranteed to be traversable. How about adding an additional type check?

            $module->runInstall($scriptPath);
        }
    }
}