Knp\FriendlyContexts\Doctrine\EntityHydrator

Complexity

Total Complexity

22

Size/Duplication

Total Lines	119
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	completeRequired()	0	4	1
A	complete()	0	14	4
A	format()	0	9	2
A	formatFromMapping()	0	19	4
B	hydrate()	0	32	5
B	completeFields()	0	25	5

<?php

namespace Knp\FriendlyContexts\Doctrine;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\DBAL\Types\Type as DBALType;
use Doctrine\ORM\Mapping\ClassMetadata;
use Knp\FriendlyContexts\Guesser\GuesserManager;
use Knp\FriendlyContexts\Utils\TextFormater;
use Knp\FriendlyContexts\Utils\UniqueCache;
use Symfony\Component\PropertyAccess\PropertyAccess;

class EntityHydrator
{
    public function __construct(TextFormater $formater, GuesserManager $guesserManager, EntityResolver $resolver, UniqueCache $cache)
    {
        $this->formater       = $formater;

The property formater does not exist. Did you maybe forget to declare it?

        $this->guesserManager = $guesserManager;

The property guesserManager does not exist. Did you maybe forget to declare it?

        $this->resolver       = $resolver;

The property resolver does not exist. Did you maybe forget to declare it?

        $this->cache          = $cache;

The property cache does not exist. Did you maybe forget to declare it?

    }

    public function hydrate(ObjectManager $em, $entity, $values)
    {
        foreach ($values as $property => $value) {
            if (false !== $mapping = $this->resolver->getMetadataFromProperty($em, $entity, $property)) {
                $this->formatFromMapping($mapping, $property, $value);
            }

            try {
                PropertyAccess::createPropertyAccessor()
                    ->setValue(
                        $entity,
                        $this->formater->toCamelCase($property),
                        $value
                    )
                ;
            } catch (\Exception $e) {
                if (!($value instanceof ArrayCollection)) {
                    throw $e;
                }

                PropertyAccess::createPropertyAccessor()
                    ->setValue(
                        $entity,
                        $this->formater->toCamelCase($property),
                        $value->toArray()
                    )
                ;
            }
        }

        return $this;
    }

    public function completeRequired(ObjectManager $em, $entity)
    {
        $this->completeFields($em, $entity);
    }

    public function completeFields(ObjectManager $em, $entity)
    {
        $accessor = PropertyAccess::createPropertyAccessor();

        $metadata = $this->resolver->getMetadataFromObject($em, $entity);

        foreach ($metadata->getColumnNames() as $columnName) {
            $property = $metadata->getFieldName($columnName);
            if (false === $metadata->isNullable($property)) {
                try {
                    if (null === $accessor->getValue($entity, $property)) {
                        $accessor->setValue(
                            $entity,
                            $property,
                            $this->complete($metadata->getFieldMapping($property), $metadata->getName())
                        );
                    }
                } catch (\Exception $ex) {
                    unset($ex);
                }
            }
        }

        return $this;
    }

    protected function complete($mapping, $className)

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

    {
        if (false === $guesser = $this->guesserManager->find($mapping)) {
            throw new \Exception(sprintf('There is no fake solution for "%s" typed fields', $mapping['type']));
        }

        if (isset($mapping['unique']) && true === $mapping['unique']) {
            return $this->cache->generate($className, $mapping['fieldName'], function () use ($guesser, $mapping) {
                return $guesser->fake($mapping);
            });
        }

        return $guesser->fake($mapping);
    }

    protected function format($mapping, $value)

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

    {
        if (false === $guesser = $this->guesserManager->find($mapping)) {

            return $value;
        }

        return $guesser->transform($value, $mapping);
    }

    protected function formatFromMapping($mapping, &$property, &$value)
    {
        $property = $mapping['fieldName'];

Equals sign not aligned with surrounding assignments; expected 11 spaces but found 1 space

        $collectionRelation = in_array($mapping['type'], [ClassMetadata::ONE_TO_MANY, ClassMetadata::MANY_TO_MANY]);
        $arrayRelation = in_array($mapping['type'], [DBALType::TARRAY, DBALType::SIMPLE_ARRAY, DBALType::JSON_ARRAY]);

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

        if ($collectionRelation || $arrayRelation) {
            $result = array_map(
                function ($e) use ($mapping) {
                    return $this->format($mapping, $e);
                },
                    $this->formater->listToArray($value)
                );

            $value = $collectionRelation ? new ArrayCollection($result) : $result;
        } else {
            $value = $this->format($mapping, $value);
        }
    }
}