MapperHydrator::readFromProperty() - Code Metrics - Inspection of "Handle php 7.4 typed properties" - b2pweb/bdf-prime - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#33)

by Vincent

created 2021-08-16 13:23 UTC

MapperHydrator::readFromProperty() A

↳ Parent: MapperHydrator

Complexity

Conditions	3
Paths	3

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3.1406

Importance

Changes

Metric	Value
eloc	8
c	0
b	0
f	0
dl	0
loc	13
ccs	6
cts	8
cp	0.75
rs	10
cc	3
nc	3
nop	4
crap	3.1406

<?php

namespace Bdf\Prime\Entity\Hydrator;

use Bdf\Prime\Entity\Hydrator\Exception\FieldNotDeclaredException;
use Bdf\Prime\Entity\Hydrator\Exception\InvalidTypeException;
use Bdf\Prime\Entity\Hydrator\Exception\UninitializedPropertyException;
use Bdf\Prime\Entity\Instantiator\InstantiatorInterface;
use Bdf\Prime\Mapper\Metadata;
use Bdf\Prime\Platform\PlatformTypesInterface;
use Error;
use ReflectionException;
use ReflectionProperty;
use stdClass;
use TypeError;

/**
 * Base implementation for @see MapperHydratorInterface
 *
 * Prefer use generated hydrators on production

 */
class MapperHydrator implements MapperHydratorInterface
{
    /**
     * @var InstantiatorInterface
     */
    protected $instantiator;

    /**
     * @var Metadata
     */
    protected $metadata;

    /**
     * Property accessors, indexed by attribute name
     *
     * @var ReflectionProperty[][]
     */
    private $reflectionProperties = [];

    /**

     * {@inheritdoc}
     */
    public function setPrimeInstantiator(InstantiatorInterface $instantiator)
    {
        $this->instantiator = $instantiator;
    }

    /**

     * {@inheritdoc}
     */
    public function setPrimeMetadata(Metadata $metadata)
    {
        $this->metadata = $metadata;
    }

    /**

     * {@inheritdoc}
     */
    public function flatExtract($object, array $attributes = null)
    {
        $values = [];
        $cache  = [];

        $attributes = $attributes === null

            ? $this->metadata->attributes

            : array_intersect_key($this->metadata->attributes, $attributes);

        foreach ($attributes as $attribute => $metadata) {
            if (isset($metadata['embedded'])) {
                $path = $metadata['embedded'];

                if (empty($cache[$path])) {
                    $cache[$path] = $this->getOwnerObject($object, $metadata);
                }

                $value = $cache[$path] ? $this->readFromAttribute($cache[$path], $metadata) : null;

            } else {
                $value = $this->readFromAttribute($object, $metadata);
            }

            $values[$attribute] = $value;
        }

        return $values;
    }

    /**

     * {@inheritdoc}
     */
    public function flatHydrate($object, array $data, PlatformTypesInterface $types)

    {
        $metadata  = $this->metadata->fields;

        $embeddeds = $this->metadata->embeddeds;
        $cacheEmbedded = [
            'root' => $object

        ];

        foreach ($data as $field => $value) {
            if (!isset($metadata[$field])) {
                continue;
            }

            $value = $types->get($metadata[$field]['type'])->fromDatabase($value, $metadata[$field]['phpOptions']);

            if (isset($metadata[$field]['embedded'])) {
                $path = $metadata[$field]['embedded'];

                //creation du cache d'objet. Le but est de parcourir les paths de l'embedded

                //de creer les objets et de les associés entre eux

                //ex:

                //  'root.wrapper.offer.id'  id est embedded dans offer qui est embedded dans wrapper, etc...

                //   l'attribute id peut etre parsé sans que wrapper ne soit déjà construit (parsqu'il n'a pas d'attribut,

                //   ou parce qu'il est définit avant dans le select)

                if (empty($cacheEmbedded[$path])) {
                    for ($i = 0, $l = count($embeddeds[$path]['paths']); $i < $l; $i++) {
                        $pathCursor = $embeddeds[$path]['paths'][$i];

                        if (empty($cacheEmbedded[$pathCursor])) {
                            $parentMeta = $embeddeds[$pathCursor];

                            if (empty($parentMeta['polymorph'])) {
                                $cacheEmbedded[$pathCursor] = $this->instantiator->instantiate($parentMeta['class'], $parentMeta['hint']);
                            } else {
                                $cacheEmbedded[$pathCursor] = $this->instantiator->instantiate(
                                    $className = $parentMeta['class_map'][$data[$parentMeta['discriminator_field']]],

                                    $parentMeta['hints'][$className]
                                );
                            }

                            $this->writeToEmbedded(
                                $cacheEmbedded[$parentMeta['parentPath']],
                                $parentMeta,
                                $cacheEmbedded[$parentMeta['path']],
                                true
                            );
                        }
                    }

                }


                $this->writeToAttribute($cacheEmbedded[$path], $metadata[$field], $value, true);
            } else {
                $this->writeToAttribute($object, $metadata[$field], $value, true);
            }

        }

    }

    /**

     * {@inheritdoc}
     */

    public function extractOne($object, $attribute)
    {
        if (!isset($this->metadata->attributes[$attribute])) {
            if (!isset($this->metadata->embeddeds[$attribute])) {
                throw new FieldNotDeclaredException($this->metadata->entityClass, $attribute);
            }

            return $this->readFromEmbedded($object, $this->metadata->embeddeds[$attribute]);
        } else {
            $ownerObject = $this->getOwnerObject($object, $this->metadata->attributes[$attribute]);

            // Polymorphic embedded not instantiated
            if ($ownerObject === null) {
                return null;
            }

            return $this->readFromAttribute($ownerObject, $this->metadata->attributes[$attribute]);
        }
    }

    /**

     * {@inheritdoc}
     */

    public function hydrateOne($object, $attribute, $value)
    {
        if (!isset($this->metadata->attributes[$attribute])) {
            if (!isset($this->metadata->embeddeds[$attribute])) {
                throw new FieldNotDeclaredException($this->metadata->entityClass, $attribute);
            }

            $this->writeToEmbedded($object, $this->metadata->embeddeds[$attribute], $value, false);
        } else {
            $ownerObject = $this->getOwnerObject($object, $this->metadata->attributes[$attribute]);

            // Polymorphic embedded not instantiated
            if ($ownerObject === null) {
                throw new \InvalidArgumentException('Cannot write to attribute '.$attribute.' : the embedded entity cannot be resolved');
            }

            $this->writeToAttribute($ownerObject, $this->metadata->attributes[$attribute], $value, false);
        }
    }

    /**
     * Get owner object attribute
     *
     * @param object $entity
     * @param array $metadata Metadata d'un attribut a retrouver
     *
     * @return object|null The object, or null if cannot be instantiated (polymorph)
     */
    protected function getOwnerObject($entity, array $metadata)
    {
        if (!isset($metadata['embedded'])) {
            return $entity;
        }

        $embeddeds = $this->metadata->embeddeds;
        $current = $entity;
        $embeddedMeta = $embeddeds[$metadata['embedded']];
        $embedded = null;

        //parcourt des paths pour descendre juqu'à l'objet propriétaire des meta données

        //si l'objet n'existe pas, on le créé avant de l'associer à son object parent

        for ($i = 0, $l = count($embeddedMeta['paths']); $i < $l; $i++) {
            $parentMeta = $embeddeds[$embeddedMeta['paths'][$i]];

            try {
                $embedded = $this->readFromEmbedded($current, $parentMeta);
            } catch (UninitializedPropertyException $e) { // The property is not initialized

                $embedded = null;
            }

            if ($embedded === null) {
                if (!isset($parentMeta['class'])) {
                    return null;
                }

                $embedded = $this->instantiator->instantiate($parentMeta['class'], $parentMeta['hint']);

                // This writes should never fail : $embedded is not null
                $this->writeToEmbedded($current, $parentMeta, $embedded, false);
            }

            $current = $embedded;
        }


        return $embedded;
    }

    /**
     * Read a value from an entity, with attribute metadata
     *
     * @param object $entity
     * @param array $metadata
     *
     * @return mixed
     *
     * @throws ReflectionException When property do not exist on the object

     * @throws UninitializedPropertyException When the property is not initialized

     */

    protected function readFromAttribute($entity, array $metadata)
    {
        $attribute = $metadata['attribute'];
        $class = get_class($entity);

        if (isset($this->reflectionProperties[$class][$attribute])) {
            try {
                return $this->reflectionProperties[$class][$attribute]->getValue($entity);
            } catch (Error $e) {
                throw new UninitializedPropertyException($class, $this->reflectionProperties[$class][$attribute]->name, $e);
            }
        }

        if (!isset($metadata['embedded'])) {
            $property = $attribute;
        } else {
            $property = substr($attribute, strlen($metadata['embedded']) + 1);

        }

        return $this->readFromProperty($class, $property, $attribute, $entity);
    }

    /**
     * Read a value from an entity, with embedded metadata
     *
     * @param object $entity
     * @param array $metadata
     *
     * @return mixed
     *
     * @throws ReflectionException When property do not exist on the object

     * @throws UninitializedPropertyException When the property is not initialized

     */

    protected function readFromEmbedded($entity, array $metadata)
    {
        $attribute = $metadata['path'];
        $class = get_class($entity);

        if (isset($this->reflectionProperties[$class][$attribute])) {
            try {
                return $this->reflectionProperties[$class][$attribute]->getValue($entity);
            } catch (Error $e) {
                throw new UninitializedPropertyException($class, $this->reflectionProperties[$class][$attribute]->name, $e);
            }
        }

        if ($metadata['parentPath'] === 'root') {
            $property = $attribute;
        } else {
            $property = substr($attribute, strlen($metadata['parentPath']) + 1);

        }

        return $this->readFromProperty($class, $property, $attribute, $entity);
    }

    /**

     * @param object $entity
     * @param array $metadata
     * @param mixed $value
     */
    protected function writeToAttribute($entity, array $metadata, $value, bool $skipInvalid)
    {
        $attribute = $metadata['attribute'];
        $class = get_class($entity);

        if (isset($this->reflectionProperties[$class][$attribute])) {
            $this->writeToReflection($this->reflectionProperties[$class][$attribute], $entity, $value, $skipInvalid, $metadata);
            return;
        }

        if (!isset($metadata['embedded'])) {
            $property = $attribute;
        } else {
            $property = substr($attribute, strlen($metadata['embedded']) + 1);

        }

        if ($class === stdClass::class) {
            $entity->{$property} = $value;
            return;
        }

        $this->reflectionProperties[$class][$attribute] = $reflectionProperty = new ReflectionProperty($class, $property);

        $reflectionProperty->setAccessible(true);

        $this->writeToReflection($reflectionProperty, $entity, $value, $skipInvalid, $metadata);
    }

    /**

     * @param object $entity
     * @param array $metadata
     * @param mixed $value
     */
    protected function writeToEmbedded($entity, array $metadata, $value, bool $skipInvalid)
    {
        $attribute = $metadata['path'];
        $class = get_class($entity);

        if (isset($this->reflectionProperties[$class][$attribute])) {
            $this->writeToReflection($this->reflectionProperties[$class][$attribute], $entity, $value, $skipInvalid, $metadata);
            return;
        }

        if ($metadata['parentPath'] === 'root') {
            $property = $attribute;
        } else {
            $property = substr($attribute, strlen($metadata['parentPath']) + 1);

        }

        if ($class === stdClass::class) {
            $entity->{$property} = $value;
            return;
        }

        $this->reflectionProperties[$class][$attribute] = $reflectionProperty = new ReflectionProperty($class, $property);

        $reflectionProperty->setAccessible(true);

        $this->writeToReflection($reflectionProperty, $entity, $value, $skipInvalid, $metadata);
    }

    /**
     * Simple property read
     *
     * @param class-string $class

     * @param string $property
     * @param string $attribute
     * @param object $entity
     * @return mixed|null

     *
     * @throws ReflectionException
     * @throws UninitializedPropertyException
     */

    private function readFromProperty(string $class, string $property, string $attribute, $entity)

    {
        if ($class === stdClass::class) {
            return $entity->$property ?? null;

        }

        $this->reflectionProperties[$class][$attribute] = $propertyReflection = new ReflectionProperty($class, $property);

        $propertyReflection->setAccessible(true);

        try {
            return $propertyReflection->getValue($entity);
        } catch (Error $e) {
            throw new UninitializedPropertyException($class, $property, $e);
        }
    }

    /**
     * Check if the value should not be hydrated, in case of null value on not nullable property
     *
     * @param ReflectionProperty $property
     * @param mixed $value
     *
     * @return bool

     */
    private function shouldSkipValue(ReflectionProperty $property, $value): bool

    {
        if (PHP_VERSION_ID < 70400 || $value !== null) {
            return false;
        }

        return $property->hasType() && !$property->getType()->allowsNull();

    }

    /**
     * @param ReflectionProperty $reflectionProperty
     * @param object $entity
     * @param mixed $value
     * @param bool $skipInvalid

     * @param array $metadata
     *
     * @throws InvalidTypeException
     */
    private function writeToReflection(ReflectionProperty $reflectionProperty, $entity, $value, bool $skipInvalid, array $metadata)

    {
        if (!$skipInvalid || !$this->shouldSkipValue($reflectionProperty, $value)) {
            try {
                $reflectionProperty->setValue($entity, $value);
            } catch (TypeError $e) {
                throw new InvalidTypeException($e, $metadata['type'] ?? null);

            }
        }
    }
}


1			<?php
2
3			namespace Bdf\Prime\Entity\Hydrator;
4
5			use Bdf\Prime\Entity\Hydrator\Exception\FieldNotDeclaredException;
6			use Bdf\Prime\Entity\Hydrator\Exception\InvalidTypeException;
7			use Bdf\Prime\Entity\Hydrator\Exception\UninitializedPropertyException;
8			use Bdf\Prime\Entity\Instantiator\InstantiatorInterface;
9			use Bdf\Prime\Mapper\Metadata;
10			use Bdf\Prime\Platform\PlatformTypesInterface;
11			use Error;
12			use ReflectionException;
13			use ReflectionProperty;
14			use stdClass;
15			use TypeError;
16
17			/**
18			* Base implementation for @see MapperHydratorInterface
19			*
20			* Prefer use generated hydrators on production
			0 ignored issues – show introduced 2020-05-22 09:38 UTC by Report Bug Copy Issue Report Doc comment long description must end with a full stop Loading history...
21			*/
22			class MapperHydrator implements MapperHydratorInterface
23			{
24			/**
25			* @var InstantiatorInterface
26			*/
27			protected $instantiator;
28
29			/**
30			* @var Metadata
31			*/
32			protected $metadata;
33
34			/**
35			* Property accessors, indexed by attribute name
36			*
37			* @var ReflectionProperty[][]
38			*/
39			private $reflectionProperties = [];

b2pweb / bdf-prime

Pull Request — master (#33)

MapperHydrator::readFromProperty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like