SplashCreateControllerService - Code Metrics - Inspection of "Service provider + better cache invalidation" - thecodingmachine/mvc.splash-common - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — fetcher_factories ( 10a56f...fd93ea )

by David

created 2016-06-01 15:49 UTC

SplashCreateControllerService D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	468
Duplicated Lines	6.41 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	5
Bugs	1	Features	1

Metric	Value
wmc	85
c	5
b	1
f	1
lcom	1
cbo	2
dl	30
loc	468
rs	4.8717

4 Methods

Rating	Name	Duplication	Size	Complexity
F	generate()	30	424	81
A	generateTwigView()	0	4	1
A	generatePhpView()	0	5	1
A	createDirectory()	0	13	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like SplashCreateControllerService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use SplashCreateControllerService, and based on these observations, apply Extract Interface, too.

<?php
namespace Mouf\Mvc\Splash\Services;

use Mouf\Composer\ClassNameMapper;
use Mouf\Mvc\Splash\Controllers\Controller;
use Mouf\Html\Template\TemplateInterface;
use Mouf\Html\HtmlElement\HtmlBlock;
use Mouf\Mvc\Splash\Utils\SplashException;
use Psr\Log\LoggerInterface;
use Mouf\MoufManager;
use Mouf\MoufCache;

/**
 * The service used to create controllers in Splash.
 */
class SplashCreateControllerService
{
    /**
     * Generates a controller, view, and sets the instance up.
     *
     * @param string $controllerName
     * @param string $instanceName
     * @param string $namespace
     * @param string $injectLogger
     * @param string $injectTemplate
     * @param string $injectDaoFactory
     * @param array  $actions
     */
    public function generate(MoufManager $moufManager, $controllerName, $instanceName, $namespace, $injectLogger = false,
            $injectTemplate = false, $injectDaoFactory = false, $actions = array())
    {
        $namespace = rtrim($namespace, '\\').'\\';

        $classNameMapper = ClassNameMapper::createFromComposerFile(__DIR__.'/../../../../../../../../composer.json');
        $possibleFileNames = $classNameMapper->getPossibleFileNames($namespace.$controllerName);
        if (!isset($possibleFileNames[0])) {
            throw new SplashException("The class '".$namespace.$controllerName."' cannot be loaded using rules defined in composer autoload section");
        }
        $fileName = $possibleFileNames[0];
        $controllerPhpDirectory = dirname($fileName);
        $errors = array();
        if (!preg_match('/^[a-z_]\w*$/i', $controllerName)) {
            $errors['controllerNameError'] = 'This is not a valid PHP class name.';
        }
        if (!preg_match('/^[a-z_][\w\\\\]*$/i', $namespace)) {
            $errors['namespaceError'] = 'This is not a valid PHP namespace.';
        }

        $namespace = trim($namespace, '\\');

        if (!file_exists(ROOT_PATH.'../database.tdbm') && $injectDaoFactory) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $injectDaoFactory = false;
        }

        // Check that instance does not already exists
        if ($moufManager->has($instanceName)) {
            $errors['instanceError'] = 'This instance already exists.';
        }

        $injectTwig = false;
        $importJsonResponse = false;
        $importHtmlResponse = false;
        $importRedirectResponse = false;

        foreach ($actions as $key => $action) {
            // Check if the view file exists
            if ($injectTemplate && $action['view'] == 'twig') {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                $injectTwig = true;
                $importHtmlResponse = true;
                $twigFile = ltrim($action['twigFile'], '/\\');

                $viewDirName = ROOT_PATH.'../../../'.dirname($twigFile);
                $result = $this->createDirectory($viewDirName);
                if (!$result) {
                    $errors['actions'][$key]['twigTemplateFileError'] = 'Unable to create directory "'.$viewDirName.'"';
                }

                if (file_exists(ROOT_PATH.'../../../'.$twigFile)) {
                    $errors['actions'][$key]['twigTemplateFileError'] = 'This file already exists.';
                }
            }
            if ($injectTemplate && $action['view'] == 'php') {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                $importHtmlResponse = true;

                $phpFile = ltrim($action['phpFile'], '/\\');

                $viewDirName = ROOT_PATH.'../../../'.dirname($phpFile);
                $result = $this->createDirectory($viewDirName);
                if (!$result) {
                    $errors['actions'][$key]['phpTemplateFileError'] = 'Unable to create directory "'.$viewDirName.'"';
                }

                if (file_exists(ROOT_PATH.'../../../'.$phpFile)) {
                    $errors['actions'][$key]['phpTemplateFileError'] = 'This file already exists.';
                }
            }
            if ($action['view'] == 'redirect') {
                if (!isset($action['redirect']) || empty($action['redirect'])) {
                    $errors['actions'][$key]['redirectError'] = 'Redirection URL cannot be empty.';
                }
                $importRedirectResponse = true;
            }
            if ($action['view'] == 'json') {
                $importJsonResponse = true;
            }
        }

        // TODO: check that URLs are not in error.


        if (!$errors) {

            $result = $this->createDirectory(ROOT_PATH.'../../../'.$controllerPhpDirectory);
            if (!$result) {
                $errors['namespaceError'] = 'Unable to create directory: "'.$controllerPhpDirectory.'"';
            } elseif (file_exists(ROOT_PATH.'../../../'.$controllerPhpDirectory.$controllerName.'.php')) {
                $errors['namespaceError'] = 'The file "'.$controllerPhpDirectory.$controllerName.'.php already exists."';
            } elseif (!is_writable(ROOT_PATH.'../../../'.$controllerPhpDirectory)) {
                $errors['namespaceError'] = 'Unable to write file in directory: "'.$controllerPhpDirectory.'"';
            }

            if (!$errors) {

                ob_start();
                echo '<?php
';
                ?>
namespace <?= $namespace ?>;

use Mouf\Mvc\Splash\Controllers\Controller;
<?php if ($injectTemplate) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
    ?>
use Mouf\Html\Template\TemplateInterface;
use Mouf\Html\HtmlElement\HtmlBlock;
<?php

}
                ?>
<?php if ($injectLogger) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
    ?>
use Psr\Log\LoggerInterface;
<?php

}
                ?>
<?php if ($injectDaoFactory) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
    ?>
use <?= $moufManager->getVariable('tdbmDefaultDaoNamespace').'\\'.$moufManager->getVariable('tdbmDefaultDaoFactoryName') ?>;
<?php

}
                ?>
<?php if ($injectTwig) {
    ?>
use \Twig_Environment;
use Mouf\Html\Renderer\Twig\TwigTemplate;
<?php

}
                ?>
<?php if ($importJsonResponse) {
    ?>
use Zend\Diactoros\Response\JsonResponse;
<?php

}
                ?>
<?php if ($importRedirectResponse) {
    ?>
use Zend\Diactoros\Response\RedirectResponse;
<?php

}
                ?>
<?php if ($importHtmlResponse) {
    ?>
use Mouf\Mvc\Splash\HtmlResponse;
<?php

}
                ?>

/**
 * TODO: write controller comment
 */
class <?= $controllerName ?> extends Controller {

<?php if ($injectLogger) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
    ?>
    /**
     * The logger used by this controller.
     * @var LoggerInterface
     */
    private $logger;

<?php

}
                ?>
<?php if ($injectTemplate) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
    ?>
    /**
     * The template used by this controller.
     * @var TemplateInterface
     */
    private $template;

    /**
     * The main content block of the page.
     * @var HtmlBlock
     */
    private $content;

<?php

}
                ?>
<?php if ($injectDaoFactory) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
    ?>
    /**
     * The DAO factory object.
     * @var DaoFactory
     */
    private $daoFactory;

<?php

}
                ?>
<?php if ($injectTwig) {
    ?>
    /**
     * The Twig environment (used to render Twig templates).
     * @var Twig_Environment
     */
    private $twig;

<?php

}
                ?>

    /**
     * Controller's constructor.
<?php
if ($injectLogger) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
    echo "     * @param LoggerInterface \$logger The logger\n";
}
                if ($injectTemplate) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    echo "     * @param TemplateInterface \$template The template used by this controller\n";
                    echo "     * @param HtmlBlock \$content The main content block of the page\n";
                }
                if ($injectDaoFactory) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    echo "     * @param DaoFactory \$daoFactory The object in charge of retrieving DAOs\n";
                }
                if ($injectTwig) {
                    echo "     * @param Twig_Environment \$twig The Twig environment (used to render Twig templates)\n";
                }
                ?>
     */
    public function __construct(<?php
$parameters = array();
                if ($injectLogger) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    $parameters[] = 'LoggerInterface $logger';
                }
                if ($injectTemplate) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    $parameters[] = 'TemplateInterface $template';
                    $parameters[] = 'HtmlBlock $content';
                }
                if ($injectDaoFactory) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    $parameters[] = 'DaoFactory $daoFactory';
                }
                if ($injectTwig) {
                    $parameters[] = 'Twig_Environment $twig';
                }
                echo implode(', ', $parameters);
                ?>) {
<?php if ($injectLogger) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
    ?>
        $this->logger = $logger;
<?php

}
                if ($injectTemplate) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    ?>
        $this->template = $template;
        $this->content = $content;
<?php

                }
                if ($injectDaoFactory) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    ?>
        $this->daoFactory = $daoFactory;
<?php

                }
                if ($injectTwig) {
                    ?>
        $this->twig = $twig;
<?php

                }
                ?>
    }

<?php foreach ($actions as $action):
    // First step, let's detect the {parameters} in the URL and add them if necessarry
    // TODO
    // TODO
    // TODO
    // TODO

?>
    /**
     * @URL <?= $action['url'] ?>

<?php if ($action['anyMethod'] == 'false') {
    if ($action['getMethod'] == 'true') {
        echo "     * @Get\n";
    }
    if ($action['postMethod'] == 'true') {
        echo "     * @Post\n";
    }
    if ($action['putMethod'] == 'true') {
        echo "     * @Put\n";
    }
    if ($action['deleteMethod'] == 'true') {
        echo "     * @Delete\n";
    }
}
                if (isset($action['parameters'])) {
                    $parameters = $action['parameters'];
                    foreach ($parameters as $parameter) {
                        echo '     * @param '.$parameter['type'].' $'.$parameter['name']."\n";
                    }
                } else {
                    $parameters = array();
                }
                ?>
     */
    public function <?= $action['method'] ?>(<?php
$parametersCode = array();
                foreach ($parameters as $parameter) {
                    $parameterCode = '$'.$parameter['name'];
                    if ($parameter['optionnal'] == 'true') {
                        if ($parameter['type'] == 'int') {
                            $defaultValue = (int) $parameter['defaultValue'];
                        } elseif ($parameter['type'] == 'number') {
                            $defaultValue = (float) $parameter['defaultValue'];
                        } else {
                            $defaultValue = $parameter['defaultValue'];
                        }
                        $parameterCode .= ' = '.var_export($defaultValue, true);
                    }
                    $parametersCode[] = $parameterCode;
                }
                echo implode(', ', $parametersCode);
                ?>) {
        // TODO: write content of action here

<?php if ($injectTemplate && $action['view'] == 'twig'): ?>
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
        // Let's add the twig file to the template.
        $this->content->addHtmlElement(new TwigTemplate($this->twig, <?php var_export($action['twigFile']);
                ?>, array("message"=>"world")));

        return new HtmlResponse($this->template);
<?php elseif ($injectTemplate && $action['view'] == 'php'): ?>
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
        // Let's add the view to the content.
        // Note: $this is passed as the scope, so in the view file, you can refer to protected
        // and public variables and methods of this constructor using "$this".
        $this->content->addFile(ROOT_PATH.<?php var_export($action['phpFile']) ?>, $this);

        return new HtmlResponse($this->template);
<?php elseif ($action['view'] == 'json'): ?>

        return new JsonResponse([ "status"=>"ok" ]);
<?php elseif ($action['view'] == 'redirect'): ?>

        return new RedirectResponse(<?php var_export($action['redirect']);
                ?>);
<?php endif;
                ?>
    }
<?php endforeach;
                ?>
}
<?php
                $file = ob_get_clean();

                file_put_contents(ROOT_PATH.'../../../'.$fileName, $file);
                chmod(ROOT_PATH.'../../../'.$fileName, 0664);

                // Now, let's create the views files
                foreach ($actions as $action) {
                    if ($injectTemplate && $action['view'] == 'twig') {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                        $twigTemplateFile = $this->generateTwigView();

                        $twigFile = ltrim($action['twigFile'], '/\\');

                        file_put_contents(ROOT_PATH.'../../../'.$twigFile, $twigTemplateFile);
                        chmod(ROOT_PATH.'../../../'.$twigFile, 0664);
                    } elseif ($injectTemplate && $action['view'] == 'php') {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                        $phpTemplateFile = $this->generatePhpView($namespace.'\\'.$controllerName);

                        $phpFile = ltrim($action['phpFile'], '/\\');

                        file_put_contents(ROOT_PATH.'../../../'.$phpFile, $phpTemplateFile);
                        chmod(ROOT_PATH.'../../../'.$phpFile, 0664);
                    }
                }

                // Now, let's create the instance
                $controllerInstance = $moufManager->createInstance($namespace.'\\'.$controllerName);
                $controllerInstance->setName($instanceName);
                if ($injectLogger) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    if ($moufManager->has('psr.errorLogLogger')) {
                        $controllerInstance->getProperty('logger')->setValue($moufManager->getInstanceDescriptor('psr.errorLogLogger'));
                    }
                }
                if ($injectTemplate) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    if ($moufManager->has('bootstrapTemplate')) {
                        $controllerInstance->getProperty('template')->setValue($moufManager->getInstanceDescriptor('bootstrapTemplate'));
                    }
                    if ($moufManager->has('block.content')) {
                        $controllerInstance->getProperty('content')->setValue($moufManager->getInstanceDescriptor('block.content'));
                    }
                }
                if ($injectDaoFactory) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    if ($moufManager->has('daoFactory')) {
                        $controllerInstance->getProperty('daoFactory')->setValue($moufManager->getInstanceDescriptor('daoFactory'));
                    }
                }
                if ($injectTwig) {
                    if ($moufManager->has('twigEnvironment')) {
                        $controllerInstance->getProperty('twig')->setValue($moufManager->getInstanceDescriptor('twigEnvironment'));
                    }
                }

                $moufManager->rewriteMouf();

                // There is a new class, let's purge the cache
                $moufCache = new MoufCache();
                $moufCache->purgeAll();

                // TODO: purge cache
            }
        }

        if ($errors) {

            $exception = new SplashCreateControllerServiceException('Errors detected');
            $exception->setErrors($errors);
            throw $exception;
        }
    }

    private function generateTwigView()
    {
        return '<p>Hello {{message}}</p>';
    }

    private function generatePhpView($controllerFQCN)
    {
        return '<?php /* @var $this '.$controllerFQCN.' */ ?>
This is your PHP view. You can access the controller protected and public variables / functions using the $this object';
    }

    /**
     * @param string $directory
     *
     * @return bool
     */
    private function createDirectory($directory)
    {
        if (!file_exists($directory)) {
            // Let's create the directory:
            $old = umask(0);
            $result = @mkdir($directory, 0775, true);
            umask($old);

            return $result;
        }

        return true;
    }
}


1			<?php
2			namespace Mouf\Mvc\Splash\Services;
3
4			use Mouf\Composer\ClassNameMapper;
5			use Mouf\Mvc\Splash\Controllers\Controller;
6			use Mouf\Html\Template\TemplateInterface;
7			use Mouf\Html\HtmlElement\HtmlBlock;
8			use Mouf\Mvc\Splash\Utils\SplashException;
9			use Psr\Log\LoggerInterface;
10			use Mouf\MoufManager;
11			use Mouf\MoufCache;
12
13			/**
14			* The service used to create controllers in Splash.
15			*/
16			class SplashCreateControllerService
17			{
18			/**
19			* Generates a controller, view, and sets the instance up.
20			*
21			* @param string $controllerName
22			* @param string $instanceName
23			* @param string $namespace
24			* @param string $injectLogger
25			* @param string $injectTemplate
26			* @param string $injectDaoFactory
27			* @param array $actions
28			*/
29			public function generate(MoufManager $moufManager, $controllerName, $instanceName, $namespace, $injectLogger = false,
30			$injectTemplate = false, $injectDaoFactory = false, $actions = array())
31			{
32			$namespace = rtrim($namespace, '\\').'\\';
33
34			$classNameMapper = ClassNameMapper::createFromComposerFile(__DIR__.'/../../../../../../../../composer.json');
35			$possibleFileNames = $classNameMapper->getPossibleFileNames($namespace.$controllerName);
36			if (!isset($possibleFileNames[0])) {
37			throw new SplashException("The class '".$namespace.$controllerName."' cannot be loaded using rules defined in composer autoload section");
38			}
39			$fileName = $possibleFileNames[0];
40			$controllerPhpDirectory = dirname($fileName);

thecodingmachine / mvc.splash-common