PHPKitchen\DI\Autoload\ClassGenerator

Complexity

Total Complexity

28

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	generateClassFileIfNotExist()	0	9	3
A	canClassBeGenerated()	0	2	1
A	isClassNotGenerated()	0	2	1
A	getClassFileNameIfExistOrGenerate()	0	8	4
A	prepareTemplateParams()	0	11	2
A	tryToGenerateClass()	0	4	2
A	isClassGenerated()	0	4	1
A	getApplication()	0	2	1
B	extractBaseClassFromDefinitionOf()	0	15	5
A	checkWhetherClassCanBeExtended()	0	9	3
A	renderTemplate()	0	7	1
A	generateClassFromTemplate()	0	5	1
A	getContainer()	0	2	1
A	buildClassFileName()	0	7	2

<?php

namespace PHPKitchen\DI\Autoload;

use Yii;

/**
 * Represents code generator that can generate virtual class definition of IoC container.
 *
 * @author Dmitry Kolodko <prowwid@gmail.com>
 */
class ClassGenerator {
    public function getClassFileNameIfExistOrGenerate($class) {
        if ($this->isClassGenerated($class) || ($this->canClassBeGenerated($class) && $this->generateClassFileIfNotExist($class))) {
            $fileName = $this->buildClassFileName($class);
        } else {
            $fileName = false;
        }

        return $fileName;
    }

    protected function canClassBeGenerated($class) {
        return $this->extractBaseClassFromDefinitionOf($class) !== false;
    }

    public function generateClassFileIfNotExist($class) {
        if ($this->isClassNotGenerated($class)) {
            $baseClassName = $this->extractBaseClassFromDefinitionOf($class);
            $isClassGenerated = $baseClassName && $this->tryToGenerateClass($class, $baseClassName);

The expression $this->tryToGenerateClass($class, $baseClassName) of type integer|false is loosely compared to true; this is ambiguous if the integer can be 0. You might want to explicitly use !== false instead.

        } else {
            $isClassGenerated = false;
        }

        return $isClassGenerated;
    }

    public function isClassNotGenerated($class) {
        return !$this->isClassGenerated($class);
    }

    public function isClassGenerated($class) {
        $classFileName = $this->buildClassFileName($class);

        return file_exists($classFileName);
    }

    public function buildClassFileName($class) {
        $baseClassName = $this->extractBaseClassFromDefinitionOf($class);
        $application = $this->getApplication();
        $runtimePath = $application ? $application->runtimePath : sys_get_temp_dir();

The condition $application can never be true.

        $fullClassName = str_replace('\\', '_', "{$class}__{$baseClassName}");

        return "{$runtimePath}/{$fullClassName}.php";
    }

    protected function extractBaseClassFromDefinitionOf($class) {
        $container = $this->getContainer();
        if (!$container) {

The condition ! $container can never be false.

            return false;
        }
        $definition = $container->getDefinitionOf($class);
        if (is_array($definition) && isset($definition['class'])) {
            $baseClassName = $definition['class'];
        } elseif (is_string($definition)) {
            $baseClassName = $definition;
        } else {
            $baseClassName = false;
        }

        return $baseClassName;
    }

    protected function tryToGenerateClass($class, $baseClass) {
        $classCanBeExtended = $this->checkWhetherClassCanBeExtended($baseClass);

        return $classCanBeExtended ? $this->generateClassFromTemplate($class, $baseClass) : false;
    }

    protected function checkWhetherClassCanBeExtended($class) {
        try {
            $baseClassReflection = new \ReflectionClass($class);
            $classCanBeExtended = !($baseClassReflection->isFinal() || $baseClassReflection->isInterface());
        } catch (\Exception $e) {
            $classCanBeExtended = false;
        }

        return $classCanBeExtended;
    }

    protected function generateClassFromTemplate($class, $baseClass) {
        $templateParams = $this->prepareTemplateParams($class, $baseClass);
        $classContent = $this->renderTemplate($templateParams);

        return file_put_contents($this->buildClassFileName($class), $classContent);
    }

    protected function prepareTemplateParams($class, $baseClass) {
        $delimiterBeforeClassNamePosition = strrpos($class, '\\');
        if ($delimiterBeforeClassNamePosition !== false) {

The condition $delimiterBeforeClassNamePosition !== false can never be false.

            $namespaceName = substr($class, 0, $delimiterBeforeClassNamePosition);
            $className = substr($class, $delimiterBeforeClassNamePosition + 1);
        } else {
            $namespaceName = false;
            $className = $class;
        }

        return compact('className', 'namespaceName', 'baseClass');
    }

    protected function renderTemplate($params) {
        ob_start();
        ob_implicit_flush(false);

false of type false is incompatible with the type integer expected by parameter $flag of ob_implicit_flush().

        extract($params, EXTR_OVERWRITE);
        require __DIR__ . '/class-template.php';

        return ob_get_clean();
    }

    /**
     * @return \PHPKitchen\DI\Container
     */
    protected function getContainer() {
        return Yii::$container;
    }

    protected function getApplication() {
        return Yii::$app;
    }
}