Vox\Data\ObjectHydrator

Complexity

Total Complexity

37

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Test Coverage

Coverage

81.82%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	isDecorated()	0	3	1
C	convertNativeType()	0	22	10
A	isNativeType()	0	12	1
C	convertDecorated()	0	29	8
B	getObjectMetadata()	0	15	5
A	convertObjectValue()	0	11	1
D	hydrate()	0	29	10
A	__construct()	0	3	1

<?php

namespace Vox\Data;

use DateTime;
use Metadata\MetadataFactoryInterface;
use RuntimeException;
use Vox\Data\Mapping\Bindings;
use Vox\Data\Mapping\Discriminator;
use Vox\Data\Mapping\Exclude;
use Vox\Metadata\ClassMetadata;
use Vox\Metadata\PropertyMetadata;

class ObjectHydrator implements ObjectHydratorInterface
{
    /**
     * @var MetadataFactoryInterface
     */
    private $metadataFactory;
    
    public function __construct(MetadataFactoryInterface $metadataFactory)
    {
        $this->metadataFactory = $metadataFactory;
    }
    
    public function hydrate($object, array $data)
    {
        $objectMetadata = $this->getObjectMetadata($object, $data);

        /* @var $propertyMetadata PropertyMetadata  */
        foreach ($objectMetadata->propertyMetadata as $propertyMetadata) {
            $annotation = $propertyMetadata->getAnnotation(Bindings::class);
            $source     = $annotation ? ($annotation->source ?? $propertyMetadata->name) : $propertyMetadata->name;
            $type       = $propertyMetadata->type;
            
            if (!isset($data[$source]) 
                || ($propertyMetadata->hasAnnotation(Exclude::class) 
                    && $propertyMetadata->getAnnotation(Exclude::class)->input)) {
                continue;
            }
            
            $value = $data[$source];
            
            if ($type && $value) {
                if ($this->isDecorated($type)) {
                    $value = $this->convertDecorated($type, $value);
                } elseif ($this->isNativeType($type)) {
                    $value = $this->convertNativeType($type, $value);
                } else {
                    $value = $this->convertObjectValue($type, $value);
                }
            }

            $propertyMetadata->setValue($object, $value);
        }
    }
    
    private function isNativeType(string $type)
    {
        return in_array($type, [
            'string',
            'array',
            'int',
            'integer',
            'float',
            'boolean',
            'bool',
            'DateTime',
            '\DateTime',
        ]);
    }
    
    private function isDecorated(string $type): bool
    {
        return (bool) preg_match('/(.*)((\<(.*)\>)|(\[\]))/', $type);
    }
    
    private function convertNativeType($type, $value)
    {
        switch ($type) {
            case 'int':
            case 'integer':
                return (int) $value;
            case 'string':
                return (string) $value;
            case 'boolean':
            case 'bool':
                return (bool) $value;
            case 'array':
                if (!is_array($value)) {
                    throw new RuntimeException('value is not array');
                }
                
                return $value;
            case 'DateTime':
            case '\DateTime':
                return new DateTime($value);
            default:
                return $value;
        }
    }
    
    private function convertDecorated(string $type, $value)
    {
        preg_match('/(?P<class>.*)((\<(?P<decoration>.*)\>)|(?P<brackets>\[\]))/', $type, $matches);
        
        $class      = isset($matches['brackets']) ? 'array' : $matches['class'];
        $decoration = isset($matches['brackets']) ? $matches['class'] : $matches['decoration'];

        switch ($class) {
            case 'array':
                if (!is_array($value)) {
                    throw new RuntimeException('value mapped as array is not array');
                }

                $data = [];

                foreach ($value as $item) {
                    $object = $this->convertObjectValue($decoration, $item);

                    $data[] = $object;
                }

                break;
            case 'DateTime':
            case '\DateTime':
                $data = DateTime::createFromFormat($decoration, $value);
                break;
        }

        return $data;

The variable $data does not seem to be defined for all execution paths leading up to this point.

    }
    
    private function convertObjectValue(string $type, array $data)
    {
        $metadata = $this->getObjectMetadata($type, $data);
        $object   = $metadata->reflection->newInstanceWithoutConstructor();

        $this->hydrate(
            $object, 
            $data
        );

        return $object;
    }
    
    private function getObjectMetadata($object, array $data): ClassMetadata
    {
        $metadata      = $this->metadataFactory->getMetadataForClass(is_string($object) ? $object : get_class($object));
        $discriminator = $metadata->getAnnotation(Discriminator::class);

The method getAnnotation() does not exist on Metadata\ClassHierarchyMetadata.

The method getAnnotation() does not exist on Metadata\MergeableClassMetadata. Are you sure you never get this type here, but always one of the subclasses?

        if ($discriminator instanceof Discriminator && isset($data[$discriminator->field])) {
            if (!isset($discriminator->map[$data[$discriminator->field]])) {
                throw new RuntimeException("no discrimination for {$data[$discriminator->field]}");
            }

            $type     = $discriminator->map[$data[$discriminator->field]];
            $metadata = $this->metadataFactory->getMetadataForClass($type);
        }
        
        return $metadata;

The expression return $metadata returns the type null|Metadata\ClassHierarchyMetadata which is incompatible with the type-hinted return Vox\Metadata\ClassMetadata.

    }
}