PSFS\base\Singleton

Complexity

Total Complexity

32

Size/Duplication

Total Lines	186
Duplicated Lines	4.84 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

89.02%

Importance

Changes	10
Bugs	2	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	load()	0	15	3
A	__construct()	0	4	1
A	__clone()	0	1	1
A	__wakeup()	0	1	1
A	__set()	0	5	2
A	__get()	0	3	2
A	isLoaded()	0	3	1
A	setLoaded()	0	3	1
A	getShortName()	0	4	1
B	init()	0	21	7
B	getClassProperties()	9	21	6
A	extractVarType()	0	7	2
A	constructInyectableInstance()	0	13	4

<?php

namespace PSFS\base;
use PSFS\base\config\Config;
use PSFS\base\types\SingletonTrait;

/**
 * Class Singleton
 * @package PSFS\base
 */
class Singleton
{
    use SingletonTrait;
    /**
     * @var bool Flag that indicated if the class is already loaded
     */
    protected $loaded = false;

    public function __construct()
    {
        Logger::log(get_class($this) . ' constructor invoked');
    }

    /**
     * prevent the instance from being cloned
     *
     * @return void
     */
    private function __clone() {}

    /**
     * prevent from being unserialized
     *
     * @return void
     */
    private function __wakeup() {}

    /**
     * Magic setter
     * @param $variable
     * @param $value
     */
    public function __set($variable, $value) {
        if(property_exists(get_class($this), $variable)) {
            $this->$variable = $value;
        }
    }

    /**
     * Magic getter
     * @param string $variable
     * @return $mixed
     */
    public function __get($variable) {

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

        return property_exists(get_class($this), $variable) ? $this->$variable : null;
    }

    /**
     * Método que devuelve si una clase está isntanciada correctamente
     * @return bool
     */
    public function isLoaded() {
        return $this->loaded;
    }

    /**
     * Método que configura como cargada una clase
     * @param bool $loaded
     */
    public function setLoaded($loaded = true) {
        $this->loaded = $loaded;
    }

    /**
     * HELPERS
     */

    /**
     * Método que extrae el nombre de la clase
     * @return string
     */
    public function getShortName() {
        $reflector = new \ReflectionClass(get_class($this));
        return $reflector->getShortName();
    }

    /**
     * Dependency inyector service invoker
     * @param string $variable
     * @param bool $singleton
     * @param string $classNameSpace

Should the type for parameter $classNameSpace not be string|null?

     * @return $this
     */
    public function load($variable, $singleton = true, $classNameSpace = null) {
        $calledClass = get_called_class();
        try {
            $instance = $this->constructInyectableInstance($variable, $singleton, $classNameSpace, $calledClass);
            $setter = "set".ucfirst($variable);
            if (method_exists($calledClass, $setter)) {
                $this->$setter($instance);
            } else {
                $this->$variable = $instance;
            }
        } catch (\Exception $e) {
            Logger::log($e->getMessage() . ': ' . $e->getFile() . ' ['  . $e->getLine() . ']', LOG_ERR);
        }
        return $this;
    }

    /**
     * Método que inyecta automáticamente las dependencias en la clase
     */
    public function init() {
        if (!$this->isLoaded()) {
            $cacheFilename = "reflections".DIRECTORY_SEPARATOR.sha1(get_class($this)).".json";
            /** @var \PSFS\base\Cache $cacheService */
            $cacheService = Cache::getInstance();
            /** @var \PSFS\base\config\Config $configService */
            $configService = Config::getInstance();
            $properties = $cacheService->getDataFromFile($cacheFilename, Cache::JSON);
            if (true === $configService->getDebugMode() || null === $properties) {
                $properties = $this->getClassProperties();
                $cacheService->storeData($cacheFilename, $properties, Cache::JSON);
            }
            /** @var \ReflectionProperty $property */
            if (!empty($properties) && is_array($properties)) foreach ($properties as $property => $class) {
                $this->load($property, true, $class);
            }
            $this->setLoaded();
        }else {
            Logger::log(get_class($this) . ' already loaded', LOG_INFO);
        }
    }

    /**
     * Método que extrae todas las propiedades inyectables de una clase
     * @param null $class
     * @return array
     */
    private function getClassProperties($class = null) {
        $properties = array();
        if (null === $class) {
            $class = get_class($this);
        }
        Logger::log('Extracting annotations properties from class ' . $class);
        $selfReflector = new \ReflectionClass($class);
        if (false !== $selfReflector->getParentClass()) {
            $properties = $this->getClassProperties($selfReflector->getParentClass()->getName());
        }
        foreach ($selfReflector->getProperties(\ReflectionProperty::IS_PROTECTED) as $property) {

This code seems to be duplicated across your project.

            $doc = $property->getDocComment();
            if (preg_match('/@Inyectable/im', $doc)) {
                $instanceType = $this->extractVarType($property->getDocComment());
                if (null !== $instanceType) {
                    $properties[$property->getName()] = $instanceType;
                }
            }
        }
        return $properties;
    }

    /**
     * Método que extrae el tipo de instancia de la variable
     * @param $doc
     * @return null|string
     */
    private function extractVarType($doc) {
        $type = null;
        if (false !== preg_match('/@var\s+([^\s]+)/', $doc, $matches)) {
            list(, $type) = $matches;
        }
        return $type;
    }

    /**
     * Create the depecency injected
     * @param string $variable
     * @param bool $singleton
     * @param string $classNameSpace
     * @param string $calledClass
     * @return mixed
     */
    private function constructInyectableInstance($variable, $singleton, $classNameSpace, $calledClass)
    {
        Logger::log('Create inyectable instance for ' . $classNameSpace . ' into ' . get_class($this));
        $reflector = new \ReflectionClass($calledClass);
        $property = $reflector->getProperty($variable);
        $varInstanceType = (null === $classNameSpace) ? $this->extractVarType($property->getDocComment()) : $classNameSpace;

This line exceeds maximum limit of 120 characters; contains 124 characters

        if (true === $singleton && method_exists($varInstanceType, "getInstance")) {
            $instance = $varInstanceType::getInstance();
        } else {
            $instance = new $varInstanceType();
        }
        return $instance;
    }
}