Gica\Serialize\ObjectHydrator\ObjectHydrator

Complexity

Total Complexity

73

Size/Duplication

Total Lines	310
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

96.27%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	hydrateObject()	0	12	3
A	hydrateObjectByReflection()	0	10	1
A	getEmptyObject()	0	4	1
A	getClassProperty()	0	9	2
A	_getClassProperty()	0	14	4
C	castValueToBuiltinType()	0	41	16
A	detectIfPropertyIsArrayFromComment()	0	9	2
A	_detectIfPropertyIsArrayFromComment()	0	12	4
A	detectClassNameFromPropertyComment()	0	9	2
A	_detectClassNameFromPropertyComment()	0	19	6
A	resolveShortClassName()	0	13	4
A	matchAndSetNonConstructorProperties()	0	21	5
A	hydrateObjectProperty()	0	5	1
C	hydrateProperty()	0	50	12
A	isScalar()	0	9	2
A	_isScalar()	0	9	2
A	parseTypeFromPropertyVarDoc()	0	9	2
A	detectClassNameFromPropertyType()	0	11	3

<?php
/******************************************************************************
 * Copyright (c) 2017 Constantin Galbenu <gica.galbenu@gmail.com>             *
 ******************************************************************************/

namespace Gica\Serialize\ObjectHydrator;


use Gica\CodeAnalysis\Shared\FqnResolver;
use Gica\Serialize\ObjectHydrator\Exception\AdapterNotFoundException;
use Gica\Serialize\ObjectHydrator\Exception\ValueNotScalar;

class ObjectHydrator
{
    /**
     * @var ObjectUnserializer
     */
    private $objectUnserializer;

    public function __construct(
        ObjectUnserializer $objectUnserializer
    ) {
        $this->objectUnserializer = $objectUnserializer;
    }

    /**
     * @param string $objectClass
     * @param $serializedValue
     * @return object
     */
    public function hydrateObject(string $objectClass, $serializedValue)
    {
        try {
            return $this->castValueToBuiltinType($objectClass, $serializedValue);
        } catch (ValueNotScalar $exception) {
            try {
                return $this->objectUnserializer->tryToUnserializeValue($objectClass, $serializedValue);
            } catch (AdapterNotFoundException $exception) {
                return $this->hydrateObjectByReflection($objectClass, $serializedValue);
            }
        }
    }

    private function hydrateObjectByReflection(string $objectClass, $document)
    {
        $reflectionClass = new \ReflectionClass($objectClass);

        $object = unserialize($this->getEmptyObject($objectClass));

        $this->matchAndSetNonConstructorProperties($reflectionClass, $object, $document);

        return $object;
    }

    private function getEmptyObject(string $className)
    {
        return 'O:' . strlen($className) . ':"' . $className . '":0:{}';
    }

    private function getClassProperty(\ReflectionClass $reflectionClass, string $propertyName): ?\ReflectionProperty
    {
        static $cache = [];
        $cache_id = $reflectionClass->getName() . '::' . $propertyName;

Consider using $reflectionClass->name. There is an issue with getName() and APC-enabled PHP versions.

        if (!isset($cache[$cache_id])) {
            $cache[$cache_id] = $this->_getClassProperty($reflectionClass, $propertyName);
        }
        return $cache[$cache_id];
    }

    private function _getClassProperty(\ReflectionClass $reflectionClass, string $propertyName): ?\ReflectionProperty
    {
        if (!$reflectionClass->hasProperty($propertyName)) {

            $parentClass = $reflectionClass->getParentClass();
            if (!$parentClass || !($property = $this->getClassProperty($parentClass, $propertyName))) {
                throw new \Exception("class {$reflectionClass->name} does not contain the property {$propertyName}");
            }

            return $property;
        }

        return $reflectionClass->getProperty($propertyName);
    }

    private function castValueToBuiltinType($type, $value)
    {
        switch ((string)$type) {
            case 'string':
                return strval($value);

            case 'mixed':
                return $value;

            case 'int':
                if (\is_int($value)) {
                    return $value;
                }
                if (is_string($value) && ($value === (string)((int)$value))) {
                    return (int)$value;
                }
                return null;

            case 'float':
                return floatval($value);

            case 'bool':
            case 'boolean':
                if (\is_bool($value)) {
                    return $value;
                }
                if ($value === '1' || $value === 'true') {
                    return true;
                } else {
                    if ($value === '0' || $value === 'false') {
                        return false;
                    }
                }
                return null;

            case 'null':
                return null;
        }

        throw new ValueNotScalar("Unknown builtin type: $type");
    }

    private function detectIfPropertyIsArrayFromComment(\ReflectionClass $reflectionClass, string $propertyName)
    {
        static $cache = [];
        $cacheId = $reflectionClass->getName() . '-' . $propertyName;

Consider using $reflectionClass->name. There is an issue with getName() and APC-enabled PHP versions.

        if (!isset($cache[$cacheId])) {
            $cache[$cacheId] = $this->_detectIfPropertyIsArrayFromComment($reflectionClass, $propertyName);
        }
        return $cache[$cacheId];
    }

    private function _detectIfPropertyIsArrayFromComment(\ReflectionClass $reflectionClass, string $propertyName)
    {
        $shortType = $this->parseTypeFromPropertyVarDoc($reflectionClass, $propertyName);
        if (null === $shortType) {
            return false;
        }
        $len = strlen($shortType);
        if ($len < 3) {
            return false;
        }
        return $shortType[$len - 2] === '[' && $shortType[$len - 1] === ']';
    }

    private function detectClassNameFromPropertyComment(\ReflectionClass $reflectionClass, string $propertyName)
    {
        static $cache = [];
        $cacheId = $reflectionClass->getName() . '-' . $propertyName;

Consider using $reflectionClass->name. There is an issue with getName() and APC-enabled PHP versions.

        if (!isset($cache[$cacheId])) {
            $cache[$cacheId] = $this->_detectClassNameFromPropertyComment($reflectionClass, $propertyName);
        }
        return $cache[$cacheId];
    }

    private function _detectClassNameFromPropertyComment(\ReflectionClass $reflectionClass, string $propertyName)
    {
        $shortType = $this->parseTypeFromPropertyVarDoc($reflectionClass, $propertyName);
        $shortType = rtrim($shortType, '[]');
        if ($shortType === '' || null === $shortType) {
            return null;
        }
        if ('array' === $shortType) {
            return null;
        }
        if ('\\' == $shortType[0]) {
            return ltrim($shortType, '\\');
        }
        if ($this->isScalar($shortType)) {
            return $shortType;
        }

        return ltrim($this->resolveShortClassName($shortType, $reflectionClass), '\\');
    }

    private function resolveShortClassName($shortName, \ReflectionClass $contextClass)
    {
        $className = (new FqnResolver())->resolveShortClassName($shortName, $contextClass);
        if (!class_exists($className)) {
            foreach ($contextClass->getTraits() as $trait) {
                $className = (new FqnResolver())->resolveShortClassName($shortName, $trait);
                if (class_exists($className)) {
                    return $className;
                }
            }
        }
        return $className;
    }

    private function matchAndSetNonConstructorProperties(\ReflectionClass $reflectionClass, $object, $document): void
    {
        foreach ($document as $propertyName => $value) {
            if ('@classes' === $propertyName) {
                continue;
            }

            try {
                $actualClassName = isset($document['@classes'][$propertyName]) ? $document['@classes'][$propertyName] : null;

                $result = $this->hydrateProperty($reflectionClass, $propertyName, $value, $actualClassName);

                $property = $this->getClassProperty($reflectionClass, $propertyName);
                $property->setAccessible(true);
                $property->setValue($object, $result);
                $property->setAccessible(false);
            } catch (\Exception $exception) {
                continue;
            }
        }
    }

    public function hydrateObjectProperty($objectClass, string $propertyName, $document)
    {
        $reflectionClass = new \ReflectionClass($objectClass);
        return $this->hydrateProperty($reflectionClass, $propertyName, $document);
    }

    private function hydrateProperty(\ReflectionClass $reflectionClass, string $propertyName, $document, ?string $actualClassName = null)
    {
        if (null === $document) {
            return null;
        }

        $isArray = null;

        if (!$actualClassName) {
            try {
                $reflectionType = $this->detectClassNameFromPropertyType($reflectionClass, $propertyName);
                $reflectionTypeString = null;
                if ($reflectionType) {
                    $isArray = false;
                    if ($reflectionType->isBuiltin()) {
                        if ($actualClassName === 'array') {
                            $isArray = true;
                        } else {
                            return $this->castValueToBuiltinType($reflectionType->__toString(), $document);
                        }
                    }
                    $reflectionTypeString = $reflectionType->__toString();
                }
                $propertyClassName = $reflectionTypeString ?? $this->detectClassNameFromPropertyComment($reflectionClass, $propertyName);
            } catch (\Exception $exception) {
                $propertyClassName = null;
            }

            if (null === $propertyClassName || 'null' === $propertyClassName) {
                return $document;
            }
        } else {
            $propertyClassName = $actualClassName;
        }

        if (null === $isArray) {
            $isArray = $this->detectIfPropertyIsArrayFromComment($reflectionClass, $propertyName);
        }

        if ($isArray) {
            $result = [];
            foreach ($document as $k => $item) {
                $result[$k] = $this->hydrateObject($propertyClassName, $item);
            }
        } else {
            $result = $this->hydrateObject($propertyClassName, $document);
        }

        return $result;
    }

    /**
     * @param $shortType
     * @return bool
     */
    private function isScalar($shortType): bool
    {
        static $cache = [];
        $cacheId = $shortType;
        if (!isset($cache[$cacheId])) {
            $cache[$cacheId] = $this->_isScalar($shortType);
        }
        return $cache[$cacheId];
    }

    /**
     * @param $shortType
     * @return bool
     */
    private function _isScalar($shortType): bool
    {
        try {
            $this->castValueToBuiltinType($shortType, '1');
            return true;
        } catch (ValueNotScalar $exception) {
            return false;
        }
    }

    private function parseTypeFromPropertyVarDoc(\ReflectionClass $reflectionClass, string $propertyName)
    {
        $property = $this->getClassProperty($reflectionClass, $propertyName);

        if (!preg_match('#\@var\s+(?P<shortType>[\\\\a-z0-9_\]\[]+)#ims', $property->getDocComment() ?? '', $m)) {
            return null;
        }
        return $m['shortType'];
    }

    private function detectClassNameFromPropertyType(\ReflectionClass $reflectionClass, string $propertyName): ?\ReflectionType
    {
        $property = $this->getClassProperty($reflectionClass, $propertyName);
        if (!$property) {
            return null;
        }
        if ($property->hasType()) {
            return $property->getType();
        }
        return null;
    }
}