Vox\Data\ObjectGraphBuilder

Complexity

Total Complexity

13

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Test Coverage

Coverage

97.44%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	createObject()	0	27	4
A	__construct()	0	4	1
A	clear()	0	5	1
B	buildObjectGraph()	0	28	5
A	fetchObject()	0	3	1
A	storeObject()	0	3	1

<?php

namespace Vox\Data;

use Metadata\MetadataFactoryInterface;
use ReflectionClass;
use ReflectionParameter;
use Vox\Metadata\ClassMetadata;
use Vox\Metadata\PropertyMetadata;

/**
 * Use object's metadata to create the entire graph of empty objects in case there's no
 * instantiated objects on the properties marked as @var Type
 * 
 * @author Jhonatan Teixeira <jhonatan.teixeira@gmail.com>
 */
class ObjectGraphBuilder implements ObjectGraphBuilderInterface
{
    private $storage = [];
    
    /**
     * @var MetadataFactoryInterface
     */
    private $metadataFactory;
    
    /**
     * @var PropertyAccessorInterface
     */
    private $propertyAccessor;
    
    private $visited = [];

    public function __construct(MetadataFactoryInterface $metadataFactory, PropertyAccessorInterface $propertyAccessor)
    {
        $this->metadataFactory  = $metadataFactory;
        $this->propertyAccessor = $propertyAccessor;
    }
    
    /**
     * @param object $object
     */
    public function buildObjectGraph($object)
    {
        if (is_string($object)) {

The condition is_string($object) is always false.

            $object = $this->createObject($object);
        }
        
        /* @var $metadata ClassMetadata */
        $metadata = $this->metadataFactory->getMetadataForClass(get_class($object));
        
        /* @var $propertyMetadata PropertyMetadata */
        foreach ($metadata->propertyMetadata as $propertyMetadata) {
            $type = $propertyMetadata->type;
            
            if (!class_exists($type)) {
                continue;
            }
            
            $dependency = $this->fetchObject($type) ?? $this->createObject($type);
            
            if (!in_array($type, $this->visited)) {
                $this->visited[] = $type;
                $this->buildObjectGraph($dependency);
            }
            
            $this->propertyAccessor->set($object, $propertyMetadata->name, $dependency);
        }
        
        return $object;
    }
    
    private function createObject($className)
    {
        $metadata = $this->metadataFactory->getMetadataForClass($className);
        
        /* @var $reflection ReflectionClass */
        $reflection = $metadata->reflection;

The property reflection does not seem to exist on Metadata\ClassHierarchyMetadata.

        
        $params = [];
        
        if ($constructor = $reflection->getConstructor()) {
            /* @var $injectable ReflectionParameter */
            foreach ($constructor->getParameters() as $injectable) {
                $typeReflection = $injectable->getClass();

                if (!$typeReflection) {
                    continue;
                }

                $object = $this->fetchObject($typeReflection->name) ?? $this->createObject($typeReflection->name);

                $this->storeObject($object);

                $params[] = $object;
            }
        }
        
        return $reflection->newInstanceArgs($params);
    }
    
    private function storeObject($object)
    {
        $this->storage[get_class($object)] = $object;
    }
    
    private function fetchObject(string $objectName)
    {
        return $this->storage[$objectName] ?? null;
    }

    public function clear()
    {
        $this->storage = $this->visited = [];
        
        return $this;
    }
}